Thing machine systems and methods

ABSTRACT

A computer-implemented method is disclosed for a first computer based machine to gain knowledge. The method includes performing a first performable machine code action to interact with a first performable machine code action to set a first thing that is representative of content, performing a second performable machine code action to interact with the thing to parse the content of the first thing as a second thing that is representative of a statement, performing a third performable machine code action to interact with the thing to evaluate the statement of the second thing to compute a third thing that is representative of a performable statement, and performing a fourth performable machine code action to interact with the thing to perform the performable statement of the third thing, the fourth performable machine code action in performing the performable statement, interacts with the thing to set one or more things that are representative of posterior knowledge.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.15/834,311, filed, Dec. 7, 2017, and entitled “THING MACHINE SYSTEMS ANDMETHODS”, which claims the benefit of U.S. Provisional PatentApplication Ser. No. 62/431,143, filed Dec. 7, 2016, entitled “THINGMACHINE SYSTEM AND METHOD,” which is incorporated by reference herein inits entirety.

FIELD OF THE INVENTION

The present invention relates to computer architecture and design, andmore particularly, is related to a Thing Machine that represents actionsthe Thing Machine can perform, and the Things that the actions act upon,as instances of Things administered in non-transitory memory using amulti-dimensional graph model.

BACKGROUND OF THE INVENTION

For a quarter of a century we have been using a web browser to renderweb pages. The browser has significantly evolved over 25 years, but atthe end of the day, it still renders a web page using a client servermodel. The cookie information, in the latest browsers, can now besynchronized in the cloud so that our state information is sharedbetween the different devices that we use.

During those 25 years, the primary access to the Web was through the useof desktop and laptop computers. Mobile devices offering web browsersstarted in the 1996 time frame. Nine years later, Google announced thatmore than half of Google searches were now originating from mobiledevices (at least in the United States).

It is important to note that a significant number of the more than 5billion web pages are not mobile friendly. For example, in 2016, it wasestimated that 54% of small businesses have a web site, and of that,only 64% of those web sites are mobile friendly. Thus, only 37% of smallbusinesses have a mobile friendly web site. It is interesting to notethat small business accounts for more than half of the sales in theUnited States every year.

Many users, frustrated by the lack of mobile friendly web pages, havedownloaded retailer mobile apps to make their experience moreproductive. Each app is dedicated to a particular business, and the appicon consumes real estate on the screen display eventually leading toclutter, as more and more apps are downloaded. As the end user, I mustspend time organizing the apps on the cell phone so that I canproductively navigate the myriad of icons to find the correct app I amin search of. The constant updates to the cell phone operating systemApplication Programming Interface (API) require a dedicated developmentteam to ensure the cell phone app is up to date. This adds an expensethat many small businesses simply cannot afford.

The emergence of Web enabled voice activated devices is becoming morecommon. A generation of children is growing up knowing they can asktheir cell phone for directions to their friend's house. Smart phones,alarm clocks, smart watches, smart TVs, Amazon Echo, home automationsystems, and even Motorcycle Helmets are just a few examples of voiceactivated devices.

Devices that are network enabled include thermostats, locks, cameras,generators, coffee machines, washers and dryers, light switches,security systems, toys, irrigation systems, and numerous other devicesand sensors. This interconnected world is sometimes referred to as theInternet of THINGs.

Hypothetically, if you could stand in the centroid of the Internet andlook out to the edges, you would see all the THINGs that are connectedto the Internet. We call this the Internet of Things that are Devicesand Sensors. If you went to the edge, picked up a device, and lookedback in toward the center, you would see the Services that are offered,and that is known as the Internet of Services.

The world became complicated when somebody realized that a service is aTHING that is offered, and suddenly there was a gray area between theInternet of THINGS as devices and sensors, and, the Internet of THINGsthat are Services. The physical Things and the virtual Things add alevel of ambiguity to the meaning of the Internet of Things, and thiscreates confusion in the market place.

To further complicate things, many physical devices often cancommunicate using multiple protocols such as: GSM, CDMA, LTE, SS7,Zigbee, Z-Wave, WeMo, Near Field Communication (NFC), Bluetooth, Thread,BLE, and others. Using our cell phone, for example, we can use NFC tomake payments by simply extending our cell phone toward the cashregister. Similarly, we can use Bluetooth to pair and connect our cellphone with the car audio system. In neither case is the device using anInternet Protocol, yet we would still consider the cell phone to be anInternet of Things Thing.

Over 35 Million interoperable Z-Wave devices have been sold since 2005(Z-Wave Alliance). A Z-Wave Network Controller is used to administeryour Z-Wave network of devices. Technically, an Internet Ready Z-WaveNetwork Controller is used to communicate over the Internet, but thecontroller still uses Z-Wave to communicate to the Z-Wave devices. Thisadds another layer of confusion on the definition of the Internet ofThings, as the Z-Wave devices are things, but, they communicate with acontroller that may, or may not be an Internet of Things Thing.

With all this confusion on the definition of the Internet of Things, Itis no wonder that the International Telecommunication Union does noteven use the keyword Internet in their description of the Internet ofThings. Instead, they define it as:

-   -   A global infrastructure for the information society, enabling        advanced services by interconnecting (physical and virtual)        things based on existing and evolving interoperable information        and communication technologies (ITU-T).        The one thing we can all agree on is: There are Things.

We classify things to describe them and categorize them. Some things areconcepts, like the value of money, legal tender, documents such as abirth certificate, a copyright, title, a bill of sale, or property. Athing can represent an event, an alert, or a unit of measure, ageolocation, or even time. Other things are objects, such as devices andsensors, a cell phone, an Ipad, or a web page. Even an action is athing, as in: don't just stand there, do something.

FIG. 1 is a schematic diagram illustrating a primitive flowchart of howa person might react to an imperative command. First, one or more of oursenses are enabled with a verb action, such as listening to a trainertelling you what to do next. You would be using a listening vocabularyfor the particular language, to parse the spoken words and create athought representative of the imperative command. Next, you evaluate thecommand to determine what to do next. Did I understand that correctly?Can I do that? Do I want to do that? Maybe I am tired and I need to restinstead.

Sometimes we generate a response, such as an acknowledgement that weunderstood what is being asked of us, and other times the response isperforming the action itself. We might give thumbs up, make a facialexpression to indicate agreement or displeasure, or, use our speakingvocabulary for a given language to communicate OK. Alternatively, inresponse to a jog in place directive, we simply start jogging in place.

The word “verb” is itself a noun that means: a word that is usually oneof the main parts of a sentence and that expresses an action, anoccurrence, or a state of being (see Merriman Webster Dictionary). Anaction is the fact or process of doing something.

We can say that some Things express an action, and other Things are theThings an action can act upon. This leads us to the Singularity ofThings: All things are Things.

In the current state of the art, the phrase “the internet of things” hasa multiplicity of definitions primarily focused on the devices andsensors connected to the Internet, instead of things such as theservices that are offered to subscribers identified by their subscriberidentifier and their password, each of which are things. This provides alimitation to the way that the implementation of algorithmic proceduresto be embodied as machine code can be modeled, thus addinginefficiencies and cost.

SUMMARY OF THE INVENTION

Embodiments of the present invention provide a Thing Machine thatrepresents actions the Thing Machine can perform, and the Things thatthe actions act upon, as instances of Things administered innon-transitory memory using a multi-dimensional graph model.

According to one aspect, a computer-implemented method for a first(P(TM)) to gain knowledge includes: performing a first P(TM(i)) tointeract with a P(TM(thing)) to set a first Thing that is representativeof content, performing a second P(TM(i)) to interact with theP(TM(thing)) to parse the content of the first Thing as a second Thingthat is representative of a statement, performing a third P(TM(i)) tointeract with the P(TM(thing)) to evaluate the statement of the secondThing to compute a third Thing that is representative of a performablestatement, and performing a fourth P(TM(i)) to interact with theP(TM(thing)) to perform the performable statement of the third Thing,The fourth P(TM(i)), in performing the performable statement, interactswith P(TM(thing)) to set one or more Things that are representative ofposterior knowledge.

According to another aspect, a computer-based system includes: one ormore computer-based processors, and computer-based memory coupled to theone or computer-based processors. The computer-based memory storescomputer-readable instructions that, when executed by the one or morecomputer-based processors, cause the one or more computer-basedprocessors to perform a method. The method includes performing a firstP(TM(i)), by executing a first section of the computer-readableinstructions that corresponds to the first P(TM(i)), to interact withanother section of the computer-readable instructions that correspondsto a P(TM(thing)), to set a first Thing that is representative ofcontent, performing a second P(TM(i)), by executing a second section ofthe computer-readable instructions that corresponds to the firstP(TM(i)), to interact with the other section of computer-readableinstructions that corresponds to the P(TM(thing)) to parse the contentof the first Thing as a second Thing that is representative of astatement; performing a third P(TM(i)), by executing a third section ofthe computer-readable instructions that corresponds to the firstP(TM(i)), to interact with the other section of computer-readableinstructions that corresponds to the P(TM(thing)) to evaluate thestatement of the second Thing to compute a third Thing that isrepresentative of a performable statement, and performing a fourthP(TM(i)), by executing a fourth section of the computer-readableinstructions that corresponds to the first P(TM(i)), to interact withthe other section of computer-readable instructions that corresponds tothe P(TM(thing)), to interact with the P(TM(thing)) to perform theperformable statement of the third Thing.

In some implementations, the P(TM), when performing the performablestatement, may interact with the other section of the computer-readablememory that corresponds to the P(TM(thing)) to set one or more Thingsthat are representative of posterior knowledge. Moreover, in a typicalimplementation, the P(TM(thing)) corresponds to yet another section ofthe computer-readable memory that, when executed, causes the one or morecomputer-based processors to organize or administer the Things and/orany mutable relationships between the Things.

In an exemplary implementation, the Thing Machine contains a processor,non-transitory memory, and/or non-transitory computer readable media,and performable machine code P(TM). The P(TM) is comprised of a firstset of performable machine code actions, having one or more performablemachine code P(TM(i)) action, wherein each performable machine codeP(TM(i)) action is configured as an implementation of an algorithmicprocedure of a model, wherein a first P(TM(i)) provides an action ofself-configuring a first vocabulary of Things in said non-transitorymemory of the Thing Machine, said Things representative of Things thatsaid processor can perform as actions, and the set of Things an actioncan act upon, and wherein at least one P(TM(i)) machine code action isperformed to configure a second vocabulary of Things in thenon-transitory memory of the Thing Machine representative of a corevocabulary through which an application can be provided.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings are included to provide a furtherunderstanding of the invention, and are incorporated in and constitute apart of this specification. The components in the drawings are notnecessarily to scale, emphasis instead being placed upon clearlyillustrating the principles of the present invention. The drawingsillustrate embodiments of the invention and, together with thedescription, serve to explain the principles of the invention.

FIG. 1 is a schematic diagram illustrating a primitive flowchart of howa person might react to an imperative command.

FIG. 2 is a schematic diagram illustrating parts of a Thing Machine, inaccordance with one embodiment of the invention.

FIG. 3 is a schematic diagram illustrating a boot process of the ThingMachine.

FIG. 4 is a graph provided for purposes of demonstrating the creation ofgraphs in accordance with the boot process, as performed by the ThingMachine.

FIG. 5 is a graph illustrating a relationship in which Thing B existsseparate from Thing A.

FIG. 6 is a graph illustrating a thing:sttia relationship.

FIG. 7 is a graph illustrating that a THING with a relationship to aperformable action is classified as a thing:verb using the thing:is-arelationship.

FIG. 8 is a graph supporting classifications, where the Namespace THINGis classified as a thing:namespace, and the thing:namespace is athing:class.

FIG. 9 is a graph illustrating supporting classifications, where theTHING is classified as a thing:context.

FIG. 10 is a schematic diagram illustrating an exemplary binding of anhttp URI to a Thing FIG. 11 is a graph illustrating a thing:graph wherea blank node represents a satisfaction claim, and the claim may have areference to a thing:object.

FIG. 12 is a graph illustrating that the thing:assertion asserts thatthe thing:subject has a value that is numeric, and thus a thing:objectis not required.

FIG. 13 is a graph illustrating when the thing:assertion claims that thevalue of thing:subject is less than the value of thing:object.

FIG. 14 is an example of a graph having a connector.

FIG. 15 is a flowchart exemplifying minimal runtime steps performed by aThing machine.

FIG. 16 is a thing:graph, such that a P(TM(i)) is P(TM(parse)) action,parsing an XML document resulting in the thing:graph so that thefollowing assertion is true: There is a Thing where Name is equal tocore:print, such that, there is a Thing where Name is equal to “message”and value is equal to “Hello, World”.

FIG. 17 is a graph such that P(TM(config)) acts upon a Thing qualifiedby the request namespace Thing, that is a G.id (illustrated as a blanknode), such that, there is a G.request and there is a G.urr.

FIG. 18 is a graph illustrating a my:configure version of theP(TM(config)) that acts upon a Thing identified by the URIrequest:statement.

FIG. 19 is a directed graph illustrating that the Thing named x is thepredecessor of the Thing named y, y is the successor of the Thing namedx, and, the predicate is the thing such that there is a relationship,which is denoted as thing:sttia

FIG. 20 is a directed graph illustrating that the Thing named x is thepredecessor of the Thing named z, and the predicate is “such that thereis an instance”, which is denoted as thing:sttiai.

FIG. 21 is an English interpreted directed graph.

FIG. 22 is a directed graph illustrating that a Thing named x is athing:table.

FIG. 23 is a directed graph showing that a multiplicity of Things have arelationship to a single Thing.

FIG. 24 is a directed graph illustrating a Thing named “x” being amember of the class of Things named “c”.

FIG. 25 is a directed graph illustrating a relationship denoting thatthe name of the Thing named “x” is a member of the class of Things named“b”.

FIG. 26 is a directed graph illustrating a relationship denoting thatthe value of the Thing named “x” is a member of the class of Thingsnamed “c”.

FIG. 27 is a directed graph illustrating that context includes arequest, a response, and, a local namespace.

FIG. 28 is a verb graph showing that classification defaults torequest:class=“thing:thing”.

FIG. 29 is verb graph corresponding to a classification defaulting torequest:class=“thing:alarm”.

FIG. 30 is a graph illustrating that G.request(P(TM(i))) indicates thatP(TM(i)) can act upon a Thing qualified in the request namespace.

FIG. 31 is a graph illustrating that G.request(P(TM(i))) indicates thatP(TM(i)) can act upon a Thing named Contact that is qualified by a Thingnamed statement, that is qualified in the request namespace.

FIG. 32 is a graph illustrating that the exemplary G(P(TM(i))) is arooted directed thing:graph that includes a G.request(P(TM(i)))subgraph, and, a G.urr(P(TM(i))) subgraph denoting how P(TM(perform)) isto request the P(TM(i)) to perform its action.

FIG. 33 is a schematic diagram illustrating a Thing Machine as auniversal Turing machine.

FIG. 34 is a schematic diagram illustrating a Thing Machine as anadaptive Neural Bot.

FIG. 35 is a graph illustrating that during initialization, P(TM(thing))allocates and initializes a Thing with the name equal to monad, as theroot of the Thing Machine's thing:graph.

FIG. 36 is a graph illustrating that the context quantifies the set ofThings that are in scope for resolving a listing comprised of one ormore free variables and expressions of relationships between them.

FIG. 37 is a graph illustrating that the context Thing is a thing:stack,through which the P(TM(thing)) can algorithmically push a Thing onto thestack, or pop a Thing off the stack, thus changing the context.

FIG. 38 is a graph illustrating that a Thing that has a representationof a reference to a performable action is classified as an Active Thing.

FIG. 39 is a graph illustrating that a G(P(TM(i))) can includeadditional Thing information, such as a description of the Things thatcomprise a response from performing P(TM(i)).

FIG. 40 is a G(P(TM(thing.set))) graph corresponding to theP(TM(Thing.set)) procedure for setting a Thing in non-transitory memory.

FIG. 41 is a G(P(TM(thing.get))) graph corresponding to theP(TM(Thing.get) procedure for getting a representation of the Thinggiven by the listing request:uri, non-transitory memory.

FIG. 42 is a G(P(TM(thing unset))) graph corresponding to theP(TM(Thing.unset) procedure for unsetting a representation of a Thingfrom non-transitory memory.

FIG. 43 is a graph illustrating that a G.request denotes that the actioncan act upon a request:statement that is a thing:statement.

FIG. 44 is a G.request subgraph indicating that an action can act upon arequest:using Thing that is a thing:listing.

FIG. 45 is a graph illustrating P(TM(eval)) algorithmically interactingwith P(TM(thing)).

FIG. 46 is a graph illustrating that the value of the Thing identifiedby the listing request: stream, is the stream to be parsed.

FIG. 47 is an exemplary graph illustrating parsed of an exemplary XMLfragment.

FIG. 48 is a graph illustrating that the value of a Thing given by therequest:input listing, is the input to parse.

FIG. 49 illustrates a G(P(TM(request))) graph.

FIG. 50 is a G.request subgraph indicating the Things that theP(TM(bind)) can act upon.

FIG. 51 is a thing:graph that is interpreted as an assertion describingthe membership requirements for a Thing to be bound as a member of theImageObject class.

FIG. 52 is an unbound thing:graph given by the listing local:object.

FIG. 53 is a thing:graph illustrating a request to bind the local:objectthing:graph as a schema:ImageObject Thing.

FIG. 54 is an assertion describing what it means for a Thing to beclassified as a BroadcastService.

FIG. 55 is a G.request subgraph indicating that a P(TM(perform)) actionacts upon a request:statement.

FIG. 56 is a graph illustrating P(TM(task.set)) interacting withP(TM(thing)) to algorithmically act-upon a Thing identified by thelisting request:statement.task, whose value is a listing of a Thing tobe set as a thing:task.

FIG. 57 is a graph illustrating P(TM(task.perform)) interacting withP(TM(thing)), P(TM(eval)), and P(TM(perform)).

FIG. 58 is a graph illustrating request:statement.listing identifying aThing whose value is a listing representative of a thing:graph that theP(TM(format)) is to format.

FIG. 59 is a graph illustrating that URI Thing qualifies a domain Thing,a path Thing, and a request Thing that qualifies a header Thing.

FIG. 60 is an illustrating of a generated HTTP Get Method request.

FIG. 61 is an illustration of a response received by P(TM(http:get)).

FIG. 62 is a set thing:graph resulting from parsing the response andinteracting with P(TM(thing)).

FIG. 63 is a graph illustrating P(TM(parse.html)) acting upon arequest:content Thing whose value is a listing representative of Thingwhose value is HTML content to parse.

FIG. 64 is an illustration of exemplary microdata in HTML content.

FIG. 65 is a thing:graph that represents microdata fromP(TM(parse.html)) providing the action of interacting with P(TM(thing))to parse content.

FIG. 66 illustrates P(TM) parsing content expressed in the ThingLanguage, that describes a desired configuration for P(TM).

FIG. 67 is a schematic representation of an exemplary implementationwhereby a P(TM(i)) action generates a performable statement, and aP(TM(perform)) causes the performance of the statement.

FIG. 68 is an exemplary flowchart showing that a P(TM(i)) action caninteract with P(TM(thing)) to set a statement Thing.

FIG. 69 is a schematic representation of an exemplary P(TM(thing))action organizing Things as a directed graph where the nodes of thegraph represent the Things and the arcs (or edges) connecting the nodesrepresent the mutable relationships between the Things.

FIG. 70 is a schematic representation of an exemplary verb vocabularyand interactions involving the verb vocabulary.

FIG. 71 is a schematic representation of an exemplary Smart ThingMachine that can perform a parse verb action to parse content received,according to a protocol, as a request.

FIG. 72 is a schematic representation of an exemplary Smart ThingMachine Communications and Protocols.

FIG. 73 is a flowchart showing an exemplary P(TM(i)) generating aperformable statement that P(TM(perform)) can cause the performance of

FIG. 74 is a flowchart of an exemplary implementation showing a P(TM(i))interacting with a P(TM(thing)) to enable the P(TM(thing)) to set aThing to be representative of the performable statement.

FIG. 75 is a schematic representation of an exemplary P(TM(thing))administering Things and the relationships between the Things.

DETAILED DESCRIPTION

The present system and method provides a novel improvement to computerfunctionality and capabilities, and even the definition of a computer,referred to herein as a Thing Machine.

A Thing that describes a performable action can be expressed in terms ofa Turing Machine. A Turing machine is a mathematical model of ahypothetical computing machine that can perform a procedure to determinea result set from a set of input variables.

-   -   For i=(1,n) TM(i) is a computational machine that can take an        input set, perform a procedural action P(TM(i)), and generate an        output set.

Any number of these machines can exist with each P(TM(i)) performing aprocedural action and potentially generating an output. The output of afirst P(TM(i)) can be the input of a second P(TM(i)), and, a set ofP(TM(i)) can often perform in parallel.

We can assign meaningful names to these actions, similar to the way wename verbs such as talk, listen, evaluate, respond, and so on. By addinga perform verb action we can ask the machine to perform a particularnamed action. Some machines, such as the Amazon Echo, or Apple Siri, canrespond to voice commands in this manner. Alexa, reorder paper towels.Siri, What time is it? In each example, we are asking a machine toperform some action, such as ordering an item, or answering a question.

To satisfy a request, a machine first needs to evaluate what is beingrequested. In some respects, this is similar to asking a 2^(nd) graderto subtract 7 from 21. The sequence includes using an English listeningvocabulary to parse the lexicons into a thought, to evaluate what thethought means, to select an action, to perform the action, and, use anEnglish speaking vocabulary to communicate a response. Alternatively,the 2^(nd) grader may shrug their shoulders and reply: I don't know.

It is also noted that requesting a machine to perform some action doesnot imply performing the same action for each person making the request.Consider, for example, a URL that is entered into a web browser, such aswww.thinglanguage.com/vl/index. By entering the URL, you are essentiallyrequesting the browser to get and display the thing identified by theURL. The identifier and the corresponding resource are both Things.

Two people requesting their browsers to get and display the same URL canhave two different results, even though they both entered the same URL.In one case, content may be specific to the individual. In another case,the HTTP request header may include state information that is used bythe Web Server to construct the resource content. It is important torecognize that a URL may identify something, but what is displayed is adifferent thing.

The Thing Machine provides a unique manner of managing and interpretinga received request based on a booting Thing Machine vocabulary thatadapts with interaction of the Thing Machine, resulting in modificationto vocabulary of the Thing Machine, where the vocabulary provides afoundation through which the Thing Machine can perform an action. As aresult, and as is demonstrated herein, the Thing Machine is able tointerpret, act, and adapt to received requests, while increasinginterpretation and action capability. Received requests, interactions,and responses to requests of the Thing Machine are performed based onthe categorization of things as either an Action Thing, which is a verbthat is an action, or a Thing that can be acted upon by the Thing thatis an Action Thing (also referred to herein as a Non-action Thing) Asmentioned above, in the singularity of Things, a Thing can represent aperformable action, or, a Thing a performable action can act upon. As isexplained and illustrated herein, the Thing machine organizes Things asa thing:graph wherein nodes of the graph represent the Things, and arcswithin the thing:graph represent mutable relationships between Things

Things that represent performable actions are referred to herein as verbthings (thing:verbs), and a collection of thing:verbs is a verbvocabulary Thing. The verb vocabulary and the Things the verb actionscan act upon, are a vocabulary Thing. In short, with a minimalvocabulary, the present system and method can use universalquantification to assert that: if ever there is a Thing that is arequest received by the Thing Machine, the Thing Machine parses therequest, then evaluates the request in the context of the availablevocabulary of the Thing Machine to select an appropriate verb, andperforms the verb's corresponding action. The performed action resultsin a set of Things representative of the response. This generalizationenables the response to be an empty set of Things for certain actionsthat do not generate a grammatical response. Sometimes, the observanceof the action being performed is a sufficient response, such as is thecase for a shutdown verb.

General Overview

The following provides an overview of the Thing Machine and associatedvocabulary, and includes three main parts:

-   -   1. A Thing Graph Data Model description that describes a Thing        as having non-mutable components including a relationship set        comprising mutable relationships between Things.    -   2. An architecture overview providing a high level overview of        the Thing Machine architecture.    -   3. A Thing Language section providing an introduction to writing        documents in the Thing Language.

Thing Machine Structure

FIG. 2 is a schematic diagram illustrating parts of a Thing Machine 100,in accordance with one embodiment of the invention. As shown by FIG. 2 ,the Thing Machine 100 contains a memory 102, a processor 104, and anon-transitory secondary storage device 106, each communicativelycoupled via a local bus, or local interface 108 allowing forcommunication within the Thing Machine 100.

The memory 102 has software 120 stored therein that defines thefunctionality described herein. The Thing Machine 100 also containsinput and output (I/O) devices 110 (or peripherals). The local interface108 can be, for example but not limited to, one or more buses or otherwired or wireless connections, as is known in the art. The localinterface 108 may have additional elements, which are omitted forsimplicity, such as controllers, buffers (caches), drivers, repeaters,and receivers, to enable communications. Further, the local interface108 may include address, control, and/or data connections to enableappropriate communications among the aforementioned components.

The processor 104 is a hardware device for executing software,particularly software that is stored in the memory 102. The processor104 can be any custom made or commercially available single core ormulti-core processor, a central processing unit (CPU), an auxiliaryprocessor among several processors associated with the Thing Machine100, a semiconductor based microprocessor (in the form of a microchip orchip set), a macroprocessor, or generally any device for executingsoftware instructions.

The memory 102 can include any one or combination of volatile memoryelements (e.g., random access memory (RAM, such as DRAM, SRAM, SDRAM,etc.)) and nonvolatile memory elements (e.g., ROM, hard drive, tape,CDROM, etc.). Moreover, the memory 102 may incorporate electronic,magnetic, optical, and/or other types of storage media. Note that thememory 102 can have a distributed architecture, where various componentsare situated remotely from one another, but can be accessed by theprocessor 104.

The software 120 defines functionality performed by the Thing Machine,in accordance with the present invention. The software 120 in the memory102 may include one or more separate programs, each of which contains anordered listing of executable instructions for implementing logicalfunctions of the Thing Machine 100, as described below. As an example,the software 120 may define a parser 122, an evaluator 124, a performer126, and a formatter 128, the functions of which are described herein.

The memory 102 may contain an operating system (O/S) 122. The operatingsystem essentially controls the execution of programs within the ThingMachine 100 and provides scheduling, input-output control, file and datamanagement, memory management, and communication control and relatedservices.

The I/O devices 110 may include input devices, for example but notlimited to, a keyboard, mouse, scanner, microphone, etc. Furthermore,the I/O devices 110 may also include output devices, for example but notlimited to, a printer, display, etc. Finally, the I/O devices 110 mayfurther include devices that communicate via both inputs and outputs,for instance but not limited to, a modulator/demodulator (modem; foraccessing another device, system, or network), a radio frequency (RF) orother transceiver, a telephonic interface, a bridge, a router, or otherdevice.

When the system Thing Machine 100 is in operation, the processor 104 isconfigured to execute the software 120 stored within the memory 102, tocommunicate data to and from the memory 102, and to generally controloperations of the Thing Machine 100 pursuant to the software 120, asexplained above.

When the functionality of the Thing Machine 100 is in operation, theprocessor 104 is configured to execute the software 120 stored withinthe memory 102, to communicate data to and from the memory 102, and togenerally control operations of the Thing Machine 100 pursuant to thesoftware 120. The operating system 122 is read by the processor 104,perhaps buffered within the processor 104, and then executed.

When the Thing Machine 100 is implemented in software 120, it should benoted that instructions for implementing the Thing Machine 100 can bestored on any computer-readable medium for use by or in connection withany computer-related device, system, or method. Such a computer-readablemedium may, in some embodiments, correspond to either or both the memory102 or the storage device 106. In the context of this document, acomputer-readable medium is an electronic, magnetic, optical, or otherphysical device or means that can contain or store a computer programfor use by or in connection with a computer-related device, system, ormethod. Instructions for implementing the system can be embodied in anycomputer-readable medium for use by or in connection with the processoror other such instruction execution system, apparatus, or device.Although the processor 104 has been mentioned by way of example, suchinstruction execution system, apparatus, or device may, in someembodiments, be any computer-based system, processor-containing system,or other system that can fetch the instructions from the instructionexecution system, apparatus, or device and execute the instructions. Inthe context of this document, a “computer-readable medium” can be anymeans that can store, communicate, propagate, or transport the programfor use by or in connection with the processor or other such instructionexecution system, apparatus, or device.

Such a computer-readable medium can be, for example but not limited to,an electronic, magnetic, optical, electromagnetic, infrared, orsemiconductor system, apparatus, device, or propagation medium. Morespecific examples (a nonexhaustive list) of the computer-readable mediumwould include the following: an electrical connection (electronic)having one or more wires, a portable computer diskette (magnetic), arandom access memory (RAM) (electronic), a read-only memory (ROM)(electronic), an erasable programmable read-only memory (EPROM, EEPROM,or Flash memory) (electronic), an optical fiber (optical), and aportable compact disc read-only memory (CDROM) (optical). Note that thecomputer-readable medium could even be paper or another suitable mediumupon which the program is printed, as the program can be electronicallycaptured, via for instance optical scanning of the paper or othermedium, then compiled, interpreted or otherwise processed in a suitablemanner if necessary, and then stored in a computer memory.

In an alternative embodiment, where the Thing Machine 100 is implementedin hardware, the Thing Machine 100 can be implemented with any or acombination of the following technologies, which are each well known inthe art: a discrete logic circuit(s) having logic gates for implementinglogic functions upon data signals, an application specific integratedcircuit (ASIC) having appropriate combinational logic gates, aprogrammable gate array(s) (PGA), a field programmable gate array(FPGA), etc.

In accordance with the first exemplary embodiment of the invention,initially, the memory 102 contains a Thing Machine procedure P(TM)(which is an executable procedure) comprised of a set of Thing Machineprocedures P(TM(i)). One skilled in the art would understand that amultiplicity of P(TM(i)) could be embodied in a single computationalmachine such as, but not limited to, a Dell Latitude 15 3000 serieslaptop running Windows 10; embodied using a system on a chip such as aRaspberry Pi 3; embodied using a multiplicity of computationalcomponents in a single machine, or, embodied using a multiplicity ofdistinct and separate machines that can communicate directly orindirectly. The Thing Machine can be embodied using plug and playarchitecture, such as, but not limited to, defined in Plug and Play I2Cslave U.S. Pat. No. 6,363,437, which is incorporated herein by referencein its entirety.

A first P(TM) comprised of a multiplicity of P(TM(i)), can be configuredas a P(TM(i)) of a second P(TM).

A Thing Machine (TM) has a procedure P(TM) that can act upon a set ofThings (for example, an input, such as a request), perform an action,and generate a set of Things (for example, an output, such as agenerated response). Following Turing's model of computability, and thata Universal Turing machine can simulate a Turing machine, we canconclude that hypothetically: P(TM)=Σ_(i=1) ^(∞)P(TM(i)). The modelindicates that we can construct a P(TM) by arranging some number n ofthese as P(TM)=Σ_(i=1) ^(n)P(TM(i)). Specifically, as is described infurther detail herein, if a first procedure of a Thing Machine requestsa second procedure of a Thing Machine to perform an action, where theThing Machine of the second procedure may or may not be the same ThingMachine as the first procedure; and in response thereto, the secondprocedure performs an action and provides a response to the ThingMachine of the first procedure, and in response to receiving theresponse, the procedure of the Thing Machine of the first procedure mayreconfigure the P(TM), if necessary. Although repetitious, it is worthnoting again, that the first and second procedures used in this example,would be first and second P(TM(i))s.

Each P(TM(i)) is an algorithmic implementation of a model, or componentthereof, expressed in performable machine code to perform a distinctsequence of steps, wherein each P(TM(i)) is performable byP(TM(perform)). In place of numbers, in accordance with the presentinvention, the Thing Machine uses words to describe the type of actiontaking place in a given P(TM(i)). P(TM(perform)) is defined in furtherdetail herein.

A model can be a representation of a selected part of the world such asmodels of phenomena, or models of data, models of theory, or models of aproblem statement in the domain of discourse (such as an applicationmodeled to solve a business problem), wherein said models are notexclusive, as scientific models can be representations of these at thesame time, and wherein the model can be expressed in terms of the Thingmodel disclosed herein. (Seehttps://plato.stanford.edu/entries/models-science/regarding “models”).

A given TM(i) with procedure P expressed as P(TM(i)) need not beprimarily a digital processor action, but may use a digital processor tocause mechanical, electrical, electromagnetic wave form, biological,chemical, generation or reception of pressure wave, generation orreception of electromagnetic radiation.

By way of example, a processor action causes a voltage to be applied toan electrical interface enabling a motor action to propel the ThingMachine in a forward or reverse direction. Said action may continueuntil a second P(TM(i)) processor action resets said voltage. Thus, theThing Machine continues performing the mechanical action while enablingP(TM) to be responsive to other thing:statements.

By way of further example, a P(TM(i)) can perform an action to interactwith recombinase-based state machines (RSMs) that use input-drivenrecombinases to manipulate DNA registers made up of overlapping andorthogonal pairs of recombinase recognition sites. Thus, the stateinformation encoded in an RSM can be interrogated or sequenced.

The P(TM) memory contains a minimal set of P(TM(i))s required toinitialize, as is described in detail within the section of the presentdescription entitled Booting. In short, in accordance with a firstexemplary embodiment of the invention, the P(TM) contains the followingP(TM(i))s: P(TM(boot)); P(TM(thing)); P(TM(parse)); P(TM(eval));P(TM(perform)); and, P(TM(configure)). The main logic of the P(TM) is toperform the P(TM(boot)), and then stop. It should be noted thatadditional or fewer P(TM(i))s may be initially provided in the P(TM)memory.

The Thing Machine is booted with a limited self-configurable bootvocabulary of Things. The P(TM(thing)) action organizes Things, and themutable relationships between them, as a thing:graph. Some Thingsrepresent performable actions. The performance of a performable actioncan act upon a Thing. A P(TM(i)) action can request P(TM(thing)) toperform an action related to administering Things, such as, but notlimited to, set, get, and unset a Thing, and/or a mutable relationshipbetween Things. A Thing can be changed by getting and setting the Thing.In addition, a Thing can be unset and set. In that respect, the Thinggraph can be viewed as the vocabulary of the Thing machine, and, thevocabulary represents its knowledge base (the actions that the ThingMachine knows how to perform, and the Things that actions can act upon).

It should be noted that, in the scope of the present disclosure, theterm “interact with” refers to a P(TM(i)) causing the performance ofmachine code related to. For example, if A “interacts with” B, then Acauses the performance of machine code related to B.

The P(TM(input)) and P(TM(output)) actions interact with anelectromagnetic waveform device to provide communication to and fromP(TM). The actions interact with P(TM(thing)) so that inbound content isa request Thing, and, outbound content is a response Thing.

The P(TM(parse)) action parses a content Thing and interacts withP(TM(thing)) to create a thing:graph representative of a statement. In afirst exemplary embodiment of a machine that acts as an interpreter, thething:graph would be a performable thing:graph. In a second exemplaryembodiment of a Thing Machine, the P(TM(eval)) action interacts withP(TM(thing)) to evaluate the thing:graph in the context of theaccessible vocabulary, to generate a performable thing:graph. Note thatthe algorithmic steps of P(TM(input)) and P(TM(parse)) can be combinedas a single procedure given by an appropriate P(TM(i)) such asP(TM(parse.input)).

The P(TM(perform)) action interacts with P(TM(thing)) to perform aThing's performable action within the context of the Things that theaction can be performed on.

The P(TM(format)) action interacts with P(TM(thing)) to format theresponse namespace Thing as the outbound content response Thing theP(TM(output)) action outputs. Note that algorithmic steps ofP(TM(format)) and P(TM(output)) can be combined as a single proceduregiven by an appropriate P(TM(i)), such as P(TM(format.output)).

The P(TM(configure)) action interacts with P(TM(thing)) to configure aP(TM(i)) as a performable Thing, also referred to as an active Thing, ora verb. This enables the vocabulary of performable actions to beupdated. Things the machine can now perform can be added, removed, or,changed in scope of complexity. Note that P(TM(i)) provides analgorithmic action, and i denotes a name representative of that action.The action may be a neural net classifier action, an electronictransaction action, or any other such algorithmic action that can bereduced to practice.

Booting

Prior to use of the Thing Machine 100, the Thing Machine 100 performs aboot process so as to allow for acclimation and future adapting to theenvironment of the Thing Machine and sources of requests received.

Each time the Thing Machine is powered on, a P(TM(boot)) actioninteracts with P(TM(thing)) to self-configure a thing:graphrepresentative of a vocabulary comprised of a set of thing:verbs, eachthing:verb being representative of an action that the P(TM(perform))action can cause the performance of, and, Things the actions can actupon, to bootstrap the machine with Things that represent the a prioriknowledge of the P(TM), such as, the last known state prior to when itwas shut down. If we define experience as the act of the Thing Machinedoing something and having Things happen (P(TM(thing)) administering thething:graph), then we could say that the Thing Machine gains experience(Things representative of actions it can perform, or knowledgerepresented as Things) as a result of performing Things.

Using said vocabulary, the Thing machine configures a core vocabulary,which provides a foundation through which it can perform an application.The performance of a P(TM(i)), can therefore interact with P(TM(thing))to change the thing:graph and said change can be thought of as theposterior knowledge (the Things that it learns from experience).

An action can traverse the thing:graph, format the content, and interactwith a secondary storage device to retain thing:graph information, whichcan then be retrieved and used by an action to reconstruct thething:graph.

In one embodiment the core vocabulary can be configured to include apre-determined set of Things, and the vocabulary is a finitepredetermined size and scope. In a second embodiment, the set of Thingsin the vocabulary is dynamically administered by the Thing Machine,wherein Things are set (learned and added to the thing:graph) and otherThings are unset (forgotten and removed from the thing:graph).

The Thing Machine organizes Things as graphs. One graph, named thecontext graph, includes Things that represent namespaces. Namespaces arenamed graphs that are used to represent conceptual groupings of Things,such as a request, a response, a set of tasks, services, a verbvocabulary, or even an application dictionary. A namespace vocabularycan be viewed as a form of ontology. Several namespaces, using discretevocabularies, however, may share in an ontological commitment for aportion of their vocabularies.

In self-configuring the graph, the P(TM(boot)) requests P(TM(thing)) toconfigure a Thing representative of a verb action, wherein said Thinghas a representation of a reference to a performable action thatP(TM(perform)) can cause the performance thereof. Exemplary verb actionsinclude, but are not limited to, parse, evaluate, perform, and config.Collectively, said things are referred to as a vocabulary, and the graphof said Things is a boot vocabulary. The boot process of the ThingMachine self-configures a limited vocabulary of the Thing Machine torepresent the machine's a priori knowledge (the initial Things in itsvocabulary). The limited vocabulary includes verbs and things that theverbs can act upon. In accordance with a first exemplary embodiment ofthe invention, the Thing Machine's basic verb vocabulary at leastincludes the verbs “input”, “output”, “parse”, “evaluate”, “perform”,and “configure”. The Thing Machine procedure associated with each verb,respectfully, is referred to as P(TM(parse)), P(TM(eval)),P(TM(perform)), and P(TM(configure)). As is described in detailhereinbelow, this enables the Thing Machine to evaluate a request in thecontext of the self-configured thing:verbs, and, to perform a configureaction that adds additional verbs to the verb vocabulary. Using thismodel, the Thing Machine's verb vocabulary becomes dynamicallyconfigurable and can increase, or decrease in size and scope as needed.

The process of self-configuring includes not only receiving of thelimited vocabulary, but also creating of at least one thing:graph foreach verb. Specifically, a verb in a thing:graph is a node, as arenon-verbs (both of which are Things), and the arcs within thething:graph represent the mutable relationships between the Things. Thething:graph therefore, defines relationships between Things that arefollowed.

The P(TM(thing)) action organizes Things, and the mutable relationshipsbetween them, as a thing:graph. Some Things represent actions,occurrences, or a state of being, and, other Things are the Things anaction can act upon. The Thing Machine is booted with a limitedself-configured boot vocabulary of Things. Using the boot vocabulary,the Thing Machine configures the a priori knowledge including a corevocabulary comprised of Things.

The P(TM(input)) action interacts with an electromagnetic waveformdevice to provide communication to P(TM). An embodiment of the presentinvention may combine P(TM(input)) with P(TM(parse)). The actioninteracts with P(TM(thing)) so that inbound content is a request Thingthat can be parsed by a parse action.

The P(TM(output)) action is an optional Thing. Its action interacts withan electromagnetic waveform device to provide communication from P(TM).

The P(TM(parse)) action parses a content Thing and interacts withP(TM(thing)) to create a thing:graph representative of a statement. In asimple machine that acts as an interpreter, the thing:graph would be aperformable thing:graph. In an adaptive Thing Machine, P(TM(eval))interacts with P(TM(thing)) to evaluate the thing:graph in the contextof the accessible vocabulary, to generate a performable thing:graph.Note that P(TM(input)) and P(TM(parse)) can be combined as a singleaction given by an appropriate P(TM(i)) such as P(TM(parse.input)).

The P(TM(perform)) action interacts with P(TM(thing)) to perform a Thingaction within the context of the Things that the action can be performedon.

The P(TM(configure)) action interacts with P(TM(thing)) to configure aP(TM(i)) as a performable Thing. This enables the vocabulary ofperformable actions to be updated. Things the machine can now performcan be added, removed, or, changed in scope of complexity. Note thatP(TM(i)) provides an algorithmic action, and i denotes a namerepresentative of that action. The action may be a neural net classifieraction, an electronic transaction action, or any other such algorithmicaction that can be reduced to practice.

Referring to the boot process and the schematic diagram of FIG. 3 , whenthe Thing Machine 100 boots, P(TM(boot)) requests P(TM(thing)) to createa boot vocabulary for the Thing Machine (block 202). P(TM(thing))receives the request and creates a Thing representative of a bootvocabulary (referred to, for exemplary purposes, as “boot:”) (block204). The creating of a Thing is performed by P(TM(thing)) initializinga unit of memory the size of a Thing where the Thing (i.e., boot:)qualifies Things in the boot vocabulary.

Thing Graph Data Model

FIG. 4 is a graph provided for purposes of demonstrating the creation ofgraphs in accordance with the boot process, as performed by the ThingMachine 100. This section defines the abstract syntax which serves tolink all Thing based languages, specification, and referenceimplementations based on RDF. RDF is a framework for representinginformation in the Web (W3C, 2014). An RDF graph is a set of triples,each consisting of a subject, predicate, and an object, as illustratedby FIG. 4 . RDF provides for three types of nodes. A node can be an IRI(see RFC 3987), a literal, or blank node. An IRI or a literal denotesomething in the world, and are called resources.

An RDF Thing graph is an RDF graph about Things. It describes thenon-mutable components of a Thing Although the components arenon-mutable, their values are mutable. Some Things are Active Thingsthat have a performable action, and are frequently referred to as verbs.Other Things are the Things that verb actions can act upon. A Thing canrepresent an RDF resource, a concept, a fact, an idea, an entity, anobject, an instance, an event, an occurrence, a device, a sensor, aservice, a task, a service, a user, a web resource, and so on.

A Thing is comprised of non-mutable components. Things are administeredby a P(TM(thing)) that has knowledge of the non-mutable components. Afirst exemplary non-mutable component of a Thing is a name that is anidentifier used to distinguish one Thing from another Thing in thedomain of discourse, though duplicate named Things can exist, such asduplicate named Things that are members of a Thing representative of alist.

A second exemplary non-mutable component of a Thing is a value. In oneembodiment, the value is an RDF literal as defined in the RDF 1.1specification. One having ordinary skill in the art would be familiarwith the RDF 1.1 specification and this specification is incorporatedherein by reference in its entirety. In addition, one having ordinaryskill in the art may use an alternative value representation as definedby an alternative specification. It should be noted that the value ofthe non-mutable component value of a Thing may be empty.

A third exemplary non-mutable component of a Thing is a relationshipset. When a Thing has an empty relationship set, then the Thing isrepresentative of a null graph. A relationship set is a set ofrelationships that hold between a first Thing and a second Thing. Theprimary relationship is one of association. Association can be in theform of composition or aggregation. If Thing A is composed of Thing B,then the relationship is immutable. If Thing A is an aggregate thatincludes Thing B, then the relationship is mutable. Wherein, by way ofexample, Thing B can exist independently of Thing A, as shown by FIG. 5. As mentioned, Things are administered by P(TM(Thing)) that hasknowledge of the non-mutable components.

A first exemplary relationship is the thing:sttia relationship, whichuses existential quantification to denote that: there is this subjectThing such that there is an object Thing. The relationship is mutable.This is illustrated by FIG. 6 .

An object THING can be representative of a collection of THINGS, such asa list of Things, or, a set of Things. The relationship can be expressedusing the instance modifier so that: there is this subject THING suchthat there is an instance of an object THING. An instance of a THING canhave different meaning depending on the THING'S classification. In onecase, an instance could be a member. In another, it could be anoccurrence of something.

The thing:is-a relationship expresses that a first THING is a type of asecond THING. This is further described herein in a section referred toas Attributes as Metadata. In a general sense, the thing:is-arelationship enables the classification of THINGS.

The thing:depends-on relationship denotes that the subject thing has adependency on the object thing. Additional relationships, such as thosefrom UML, can be added to the RDF Thing Graph Data Model. These wouldinclude association, aggregation, directed association, composition,reflexive association, inheritance, multiplicity, and realization.

Identifiers and Listings

A listing is a representation of a reference to a Thing. A listing maybe an unbound name, such as an identifier, or, expressed to convey therelationship between two or more Things. The listing “this” is a simpleidentifier that denotes that we are referring to the Thing where thename is equal to “this”. The listing “this.that” can indicate that thereis a Thing where the name is equal to “this”, such that, there is aThing where name is equal to “that”. The exact interpretation of alisting is dependent on the namespace that the listing is bound to, andthis is covered in more detail in the section on URIs (see RFC 3986), asdescribed below.

Attributes as Metadata

An attribute describes an inherent characteristic, or a quality of aTHING. Attributes are expressed as metadata. The thing:metadata is aTHING that identifies a type of attribute, and the THING'S valuedescribes the attribute value.

An attribute can be identified as a thing:metadata and subsequently usedin a triple. As an example, a thing:class attribute is used to denotethe classification of a THING. A class is a set of THINGS that satisfythe membership criterion that specifies what is required for a THING tobe a member of the class at a given moment in time. The intention is thetime dependent criterion. The extension at a given moment in time is thelisting of all members at that time.

An attribute may describe a state. For example, a THING can be declaredwithout denoting its classification, and, a binding action can act uponthe “unbound” THING to bind it to something that the binding action canrecognize, even if bound as an “unknown” THING. The binding actiontransitions the THING from the unbound to the bound state. A bound THINGcan be found, or unfound. A bound THING that is found indicates thebinding action was able to bind the THING to something it understands. Abound THING that is unfound indicates the binding action was applied tothe THING, but, the THING is not something that the binding action wasable to understand.

Active Things

A THING that has a representation of a reference to a performable actionis classified as an Active Thing. In this context, a performable actionis an action that a machine can cause to be performed to achieve someresult, and may be predominantly computational, electrical, chemical,optical, biological, mechanical, electromagnetic wave form, or acombination thereof, in nature.

An Active Thing herein is often referred to as thing:verb in that a verbis a noun that describes an action, and an Active Thing describes anaction. Thus, the name of the Active Thing is a verb whose identifierdescribes an action that can be performed.

In an implementation supporting classifications, a THING with arelationship to a performable action is classified as a thing:verb usingthe thing:is-a relationship, as shown by FIG. 7 .

A verb can act upon a set of THINGS. The THINGS that can be acted upon,can be explicitly specified in an RDF THING graph, or implicitlyspecified by classification. Quantifiers can be used to limit the scopeof THINGS in the domain of discourse, to THINGS that the verb action canact upon.

Namespaces

A namespace is a THING that represents a named graph of somehowlogically related THINGS, even if related solely by being members of thesame namespace. The graph includes the THINGS, and their relationships.As illustrated by FIG. 8 , in a graph supporting classifications, theNamespace THING is classified as a thing:namespace, and thething:namespace is a thing:class.

Context

A context is a THING that quantifies the set of namespaces that havecurrent scope. As shown by FIG. 9 , in a graph supportingclassifications, the THING is classified as a thing:context.

The context enables a set of namespaces to have current scope, for usein dereferencing an IRI representative of a THING. For example,request:statement is an IRI that can be resolved relative to a context.In English, this would be expressed as: There is a namespace where thename is equal to request, such that, there is a Thing where the name isequal to statement.

URIs

A URI identifies a resource, and a THING is a representation of thatresource in the THING Machine. THINGS either have a performable action,or, are THINGS that a performable action can act upon. The generalizedform of a URI is given as:

scheme: scheme specific part

In the THING MACHINE, the scheme is interpreted as a reference to anamespace THING whose name follows the naming convention for a URIscheme, as shown below. This has the advantage that existing schemenames can be represented using RDF THING graphs.

-   -   A Namespace Name consists of a sequence of characters beginning        with a letter and followed by any combination of letters,        digits, plus (“+”), period (“.”), or hyphen (“-”)-RFC 3986.

All permanent URI Schemes, as published by the Internet Assigned NumbersAuthority, are reserved namespace names. Modeling of THINGs in areserved namespace should conform to the meaning of the published RFCfor that namespace. For example, to model THINGs in the news: and thenntp: namespaces, one should consult RFC5538. The list of published URISchemes is maintained by the IANA and is available online at:www.iana.org/assignments/uri-schemes.

The “URN” namespace is a reserved namespace, and its namespace-specificpart is interpreted as defined by the corresponding published RFCdocument for that URN namespace. The list of published URNs ismaintained by the IANA and is available online at:www.iana.org/assignments/urn-namespaces/urn-namespaces.

The namespace specific portion of the listing is interpreted accordingto the specification of the namespace (scheme).

-   -   A parser of the generic URI syntax can parse any URI reference        into its major components. Once the scheme is determined,        further scheme-specific parsing can be performed on the        components. In other words, the URI generic syntax is a superset        of the syntax of all URI schemes.—RFC 3986.

The http:, the https:, and the file: namespaces, however, use the “I”character delimiter so that the reference:http://www.THINGlanguage.com/request is interpreted as:

-   -   There is a THING:NAMESPACE where Name is equal to “http”, such        that, there is a THING where Name is equal to        “www.THINGlanguage.com”, such that, there is a THING where Name        is equal to “request”.

The mail to namespace interprets the references according to RFC6068.For example, the reference: mailto:info@thinglanguage.com is interpretedas:

-   -   There is a THING:NAMESPACE where Name is equal to “mailto”, such        that, there is a THING where Name is equal to        info@THINGlanguage.com.

The THINGs: scheme, supported in OSX and IOS, can also be modeled. TheTHINGs: URI is given as: THINGs:command?parameter1=valuel&parameter2 . .. This would be interpreted as:

-   -   There is a THING:NAMESPACE where Name is equal to “THINGs”, such        that, there is a THING where Name is equal to “command”, such        that there is an instance of a THING where Name is equal to        “parameter1” and Value is equal to “value 1”, and, there is an        instance of a THING where Name is equal to “parameter2”.

The name of a Namespace THING follows the naming requirements of an IRIscheme (see RFC 3987). This serves as a way to bind a URI (a form of anIRI, and described in RFC 3986) to a THING. The URI scheme name is boundto a Namespace THING. All http: URIs, for example, are bound within thehttp: Namespace THING. An exemplary binding of an http URI to a THING isillustrated in FIG. 10 .

Satisfaction Claims

The basic assertion is a thing:assertion representative of asatisfaction claim, and it asserts that a given claim is true. In theThing Graph Model, an assertion is a Thing instead of being a directededge label. Referring to FIG. 11 , in thing:graph, the blank noderepresents a satisfaction claim, and the claim may have a reference to athing:object.

As illustrated by FIG. 12 , the thing:assertion asserts that thething:subject has a value that is numeric, and thus a thing:object isnot required.

As illustrated by FIG. 13 , the thing:assertion claims that the value ofthing:subject is less than the value of thing:object.

The truthfulness of a satisfaction claim is determined by thecomputational procedure corresponding to the claim. In that regard, asatisfaction claim is an Active Thing having a corresponding thing:graphdescribing the Things that the action can act upon.

Exemplary satisfaction claims include, but are not limited to thoseillustrated by the following table 1:

TABLE 1 thing:is-less-than The value of THING:subject is less than thevalue of THING:object. thing:is-less-than-or- The value of THING:subjectis less than or equal-to equal to the value of THING:object.thing:is-equal-to The value of THING:subject is equal to the value ofTHING:object. thing:is-greater-than-or- The value of THING:subject isgreater than or equal-to equal to the value of THING:object.thing:is-greater-than The value of THING:subject is greater than thevalue of THING:object. thing:matches The value of THING:subject matchesthe value of THING:object. thing:is The THING is in a state, or has astate, as specified by THING:object. thing:is-a The THING is a class ofa THING specified by THING:object.

The “is” portion of the simple predicates can be followed by “not” toindicate the negation of the predicate. For example,thing:is-not-equal-to. The negation of thing:matches would be specifiedas thing: does-not-match.

Connectors

Logical connectors are used to connect two satisfaction claims.Exemplary connectors include, but are not limited to, and, or, not,implies, and iff. Similar to satisfaction claims, the logical connectorsare expressed as Things, not as directed edge labels. Logical connectorThings are Active Things. An example of a graph having a connector isprovided by FIG. 14 .

Examples of simple connectors include, but are not limited to thefollowing illustrated by table 2.

TABLE 2 thing:and A conjunction formed by joining the two statementsthing:subject and the thing:object with the connector thing:and. Theconjunction is true if both thing:subject and thing:object aresatisfied. thing:or The disjunction is true when either or both ofthing:subject and the thing:object are satisfied. thing:xor An exclusivedisjunction is satisfied if either thing:subject, or thing:object aresatisfied, but not both of them. thing:not The thing:subject issatisfied, and thing:object is not satisfied. thing:implies Thething:subject, if satisfied, implies the thing:object is satisfied.thing:iff If thing:subject and thing:object are satisfied, or, ifthing:subject and thing:object are not satisfied, then thing:iff issatisfied.

While it is true that in a Procedural graph a satisfaction claimevaluates to True (satisfied) or False (not satisfied), a satisfactionclaim in a Declarative graph can expand to include the set of Thingsthat the claim ranges over.

Graph Types

A THING graph is procedural in nature when it describes how to dosomething. For example, a graph to set a THING'S value is a proceduralstatement, as is a sequence of statements describing the actionsnecessary to perform a task.

A THING graph is declarative when it is a statement representative of adeclaration. HTML is an example of declarative statements. The HTMLsource code describes the desired layout of a document, and an HTMLrendering engine will process it to perform the actual layout.

A THING graph is object oriented when it describes objects and theirmethods. As an example, a graph denoting an object and the methods toset, get, and unset the object would be object oriented.

A THING graph is an event driven graph when events such as messages orstates drive the evaluation of the graph. A THING graph is a FiniteState graph when it expresses the states and the transitions betweenstates, for use in a Finite State Machine.

A THING graph may be a combination of one or more of the above types ofgraphs, such as a Harel statechart, an XML statechart, or a UMLstatechart.

-   -   Modeling Reactive System with Statecharts: The STATEMATE        Approach by D. Harel and M. Politi. McGraw-Hill, 1998.    -   (See        http://www.wisdom.weizmann.ac.il/˜dharel/reactive_systems.html.)

A Thing machine procedure P(TM(thing)) expressed in performable machinecode provides the action of administering Things, and the relationshipsbetween them, in non-transitory memory. A Thing having a representationof a reference to a performable action is a verb. A Thing machineprocedure P(TM(perform)) expressed in performable machine code providesthe action of interacting with P(TM(thing)) to get a reference to a verbThing, and, to cause the performance of the verb's performable action(the P(TM(i)). The performance of the action can interact withP(TM(thing)) action to act upon a Thing in non-transitory memory. AThing machine procedure P(TM(configure)) expressed in performablemachine code provides the action of interacting with P(TM(thing)) to seta verb Thing Thus we can describe a problem statement and architect asolution in terms of Things that the Thing machine can perform asactions and the Things the actions can act upon.

FIG. 15 is a flowchart 250 exemplifying minimal runtime steps performedby a Thing machine. It should be noted that any process descriptions orblocks in flowcharts should be understood as representing modules,segments, portions of code, or steps that include one or moreinstructions for implementing specific logical functions in the process,and alternative implementations are included within the scope of thepresent invention in which functions may be executed out of order fromthat shown or discussed, including substantially concurrently or inreverse order, depending on the functionality involved, as would beunderstood by those reasonably skilled in the art of the presentinvention.

Specifically, it should be noted that at least the following steps areperformed by a Thing Machine. As shown by block 252, a P(TM(i)) actionalgorithmically, such as by parsing input, or interacting with thesensor, or by requesting the Thing Machine to perform an action,generates a thing:graph representative of a statement for the ThingMachine to evaluate and perform an action.

This is useful for a P(TM(i)) that obtains sensor generated data, such atemperature, acceleration, altitude, longitude, and/or latitude, motionsensor, heat sensors, smoke sensors, or other such sensor, toincrementally construct a thing:statement to be evaluated and acorresponding performable thing:statement to be performed. Similarly, aP(TM(i)) that is notified of a signal, such as an event, a timer, aninterrupt, or an alarm, can interact with P(TM(request)) to construct athing:statement to be evaluated and a corresponding performablething:statement to be performed to enable P(TM) to be responsive toreceipt thereof.

A first exemplary embodiment of such a P(TM(i)) is P(TM(parse)) action,parsing an XML document resulting in a thing:graph so that the followingassertion is true:

There is a Thing where Name is equal to core:print, such that, there isa Thing where

Name is equal to “message” and value is equal to “Hello, World”.

The corresponding thing:graph is illustrated in FIG. 16 .

As shown by block 254, a P(TM(eval)) action interacts with P(TM(thing))to access and interact with said thing:graph and with current verbvocabulary to algorithmically select an appropriate verb action andconstruct and set a performable thing:graph. It should be noted that thecurrent verb vocabulary may be the initial verb vocabulary or may be adynamically changed verb vocabulary.

As shown by block 256, the P(TM(perform)) action interacts withP(TM(thing)) to get the performable thing:graph, and causes theperformance thereof. In accordance with an alternative embodiment of theinvention, the Thing Machine may not contain the P(TM(eval)) action. Insuch an embodiment, the P(TM(parse)) interprets imperative statements.

Changing the Thing:Graph/Core Vocabulary

As previously mentioned, a P(TM(i)) can interact with a P(TM(thing)) toset a thing:graph. The Thing architecture enables the specifics of theinput and the output to be abstracted away and come into existencethrough the use of verb actions. The choice of language, grammar,syntax, and the communication actions themselves, are simply Things.

Any number of languages and syntax can be received in the P(TM(i)) inputstream and can be parsed as long as the P(TM(parser)) action canalgorithmically parse the elements of the grammar syntax into athing:graph.

A language is a THING, more precisely described as a system ofcommunication that includes a lexicon and a grammar. The lexicon is thevocabulary, such as the set of words or phrases in the language. Thegrammar imposes the rules such as the morphology, the semantics, and,the syntax.

An action is a Thing that must be performed to communicate. Visualcommunication skills such as reading and observing can be used. Physicalactions such as writing or signing can be used. Oratory and audiocommunication skills can be used. Alternatively, a Braille writingsystem could be used. All of these are Things, and because they areThings, their actions can be modelled and configured as actions theThing Machine (i.e., P(TM)) can perform.

Gesturing, as a form of communication action, transcends societies. Themeaning of a finger pointed in a direction; the stamping of feet; or,the smile on your face are generally understood. Gesturing is distinctfrom sign languages in that the latter uses established expressions andmotions with well-defined meaning. Gesturing is a Thing.

Similar to people, the Thing machine can have a reading vocabulary, awriting vocabulary, a listening vocabulary, and a speaking vocabularyfor a given language. Each of these vocabularies can be at differentlevels. The Thing Machine may know by way of configured Things, what aword means when the Thing Machine hears it, but not be able to pronounceit, or, spell it correctly. Similarly, the Thing Machine may readsomething, and see a word that it does not recognize. The word ossify,for example, is a verb word in the English language, meaning to hardenlike a bone, but may be one of the least commonly used verbs in thelanguage, and therefore, a modelled embodiment may not be configured inthe Thing Machine's verb vocabulary.

When the Thing Machine identifies an unfamiliar word, it may try tointerpret meaning of the word by interacting with its syllables. If itcan detect a root, it may be able to infer meaning. As the Thing Machinelearns new words and how to use them, it can add them to its variousvocabularies.

A multi-lingual Thing Machine can have a different vocabulary capabilityfor each language it knows. A Thing Machine could be modelled on thelinguistic educational system of Arubian students, who learn Papiamento,Dutch, Spanish, and English languages in school. Each Thing Machinecould develop its reading vocabulary, writing vocabulary, listeningvocabulary, and speaking vocabulary, at different rates and potentiallyto different capabilities, for each language.

The Thing Machine can parse a statement according to the grammar andsyntax into token Things; and, bind the token Things to a Thing in theircorresponding vocabulary. Certain Things can be immediately classified,whilst others require looking at the surrounding words to infer meaning.

The meaning of a statement can still be ambiguous. Consider thestatement: “Let's eat honey”. It could mean to eat honey, or, it couldmean you're inviting your loved one to start eating. As is explained indetail herein, to help manage the interpretation and meaning of astatement, we introduce the idea of a Thing verb graph wherein thestarting node is the verb name, and the connected nodes are the Thingsthat the verb action can act upon.

It is important to note that other verb (P(TM(i))) actions, besidesP(TM(parse)), can subsequently be configured such that when performedthe action interacts with P(TM(thing)) to create a thing:graph, whereinsaid thing:graph can subsequently be evaluated to create a performablegraph. The performance of a performable thing:graph can cause an actionto interact with P(TM(thing)), to change the thing:graph of the Thingsthat P(TM(thing)) administers. An exemplary embodiment of such aP(TM(i)) is P(TM(config)), providing the action of interacting withP(TM(Thing)) to configure a set of Active Things (where a set is one ormore).

The action of a P(TM(i)) can interact with the environment to generate athing:graph representation of a request to change the thing:graphadministered by P(TM(thing)). In response thereto, P(TM(config))interacts with P(TM(thing)) to change the thing:graph administered byP(TM(thing)). Thus, the action of P(TM(config)) changes the currentvocabulary, which is also referred to herein as a core vocabulary.

Referring to FIG. 17 , the P(TM(config)) acts upon a Thing qualified bythe request namespace Thing, that is a G.id (illustrated as a blanknode), such that, there is a G.request and there is a G.urr.

The name of the G.id Thing is an identifier of a verb Thing thatP(TM(config)) is to configure. The G.request is a graph describing theThings that the performance of the verb Thing can act upon. The value ofthe G.urr Thing is a URI that is interpreted as a Uniform ResourceRequest for requesting performance of the verb Thing.

Referring to FIG. 18 , the my:configure version of the P(TM(config))acts upon a Thing identified by the URI request:statement, such thatthere is a Thing that is a vocabulary identifier (vocabulary.id) andsuch that there is a Thing that is a graph ID such that, there is aG.request and a G.urr. A vocabulary identifier can be used by aclassifier in algorithmically selecting the set of verb Things in thedomain of discourse for the P(TM(eval)) to use in evaluating athing:statement.

In an embodiment, P(TM(config)) can interact with a Thing representativeof a shared library such as a Dynamic Link Library, such that saidshared library is dynamically loaded into the process memory, and, areference to a function is resolved and executed to provide a set ofProcedures and corresponding graphs, thereby enabling a multiplicity ofverb Things to be configured.

In an embodiment, P(TM(config)) can algorithmically interact withP(TM(eval)) and P(TM(perform)) to evaluate and perform a thing:statementthat must be satisfied as a prerequisite to configuring a set of verbThings. Said thing:statement can be representative of a request to checkfor accessibility, versioning information, revision information,dependencies, conflicts with existing verb Things, identification,authorization, authentication, security, a hardware capability, anoperating system capability, or other such activities.

In an embodiment supporting identity, authentication, and authorization,the P(TM(config)) action can interact with a P(TM(i)) to identify andauthenticate a thing:statement, and to enforce authorizationrequirements required to be satisfied to configure verb Things. By wayof example, a thing:statement may require a digital signature with anidentity that can be authenticated, to determine if the identity isauthorized to request the P(TM(config)) to perform its action. Varioussecurity models can be algorithmically enabled and said model mayrequire the use of specific hardware and P(TM(i)) configured verbThings, such as that disclosed in the pending U.S. Patent Applicationhaving Ser. No. 62/288,545, entitled Optical Identity System andMethods, filed on Jan. 29, 2016, which is incorporated by referenceherein in its entirety (the optical identifier patent application). Anembodiment may use P(TM(openssl)) to provide identity, authentication,and authorization actions enabled by OpenSSL Toolkit (see theopenssl.org web site.

Examples of Types of Things

An action block is a thing:graph representative of a sequence ofstatements. A named action block is referred to as a task. In thismanner, the language grammar can express a request for the Thing Machineto configure a named task that it can subsequently perform. The task isperformed by performing the action block. The action block is performedby evaluating each statement to generate a performable thing:graph. Theperformable thing:graph is performed by performing the actioncorresponding to the thing:verb in the performable thing:graph.

A Thing Machine can be configured to be bilingual in that a multiplicityof language grammar parsers can be configured as performable actions.Alternatively, a translator action can be used to translate from a firstlanguage to a second language that can be parsed by the configuredparser action.

Thus when we say a Thing Machine can read a book, we mean that a ThingMachine can perform an action to interact with content obtained from aninput device, to represent the content as a thing:graph. By retainingthe thing:graph as a subgraph of the overall Thing Machine, a ThingMachine action can subsequently access and interact with that content.

A Thing Machine can read a book describing how to perform a task, andretain that knowledge in the event the machine is ever asked to performsuch a task in the future. A task can be classified by topic. A task maybe a member of a set of classifications, such as a Task related to usingthe http protocol; a task related to an activity such asaccounting:accounts.receivable, accounting:accounts.payable,banking:debits, banking:credits, and, banking:balance.

A first Thing Machine can send a communication intended for a secondThing Machine, requesting knowledge about a topic or classification. Inresponse to receiving content representative of said knowledge, thefirst Thing Machine can interact with the content to configure its ownknowledge accordingly. In this manner, a first Thing Machine can learnfrom a second Thing Machine.

The THING Machine can provide services. A service is a THING that isprovided in response to receiving a request. The subtle distinctionbetween a service and a task is that tasks are performed; whilstservices are provided. The separation of tasks versus services isfacilitated through the context, which can prevent the unauthorizedperformance of a task, such as a task to remove files or change themeaning of a verb.

As mentioned, a context Thing quantifies the set of available namespaceThings in the domain of discourse. A namespace Thing qualifies a set ofrelated Things, even if related simply by being members of the samenamespace. The name of the namespace Thing is used in resolvingreferences to Things.

Identity is a THING, and as such we can model the concepts ofidentifiers, authentication, authorization, and auditing to embody anidentity model. Examples of identity models include the use of a PublicKey Infrastructure, Open PGP's web of trust, biometrics, 3^(rd) partyauthorization, and others. With identity, we can introduce a marketplaceas a Thing and enable transactions. A transaction becomes a THINGbetween a buyer and a seller; a payer and a payee. The transaction mayinvolve a service offering THING, a physical THING, a conceptual Thing,or a logical THING.

The identity model enables authentication of a graph or subgraph.Consider, for example, a graph representative of a request including arequesting party identifier (i.e., request originator), content, and, adigital signature, of the content. The corresponding certificate of theidentifier can be validated, and the digital signature of the contentvalidated. This enables an evaluate action to algorithmically validate arequest and select an appropriate action in response thereto. With anidentity model in place, we can also provide a secure communicationmodel.

Securing the request content can be modeled using cipher actions toencrypt and subsequently decrypt content. The request graph can includea subgraph describing a cipher action, and, a cipher key. The evaluateverb action can apply, as a prerequisite, that the specified cipher mustfirst be performed with the specified key, to decrypt the content. Byorganizing the various components of the request in appropriatesubgraphs, two or more Thing Machines can algorithmically communicateusing an identity model, and secure communications.

When integrated with an Optical Identifier SIM card, or similar device,the THING Machine can be modeled as a THING with unique identity in anoverlay network, even on an ad-hoc basis. THINGs can disengage from thenetwork, and re-engage elsewhere in the network, yet retain theiroptical identity.

Optical identity can be discrete from user identity. This enables aThing Machine to verify itself on the overlay network, and, use thenetwork available content to reconfigure itself based on the identity ofthe user.

A THING Machine can dynamically configure and reconfigure itsvocabularies, even on an ad-hoc basis. A set of Thing Machines thatshare an ontological commitment to at least a subset of their lexicon,can interact with Things using that subset (or at least a part thereof).Given that the vocabulary is represented as Things, and that the ThingMachine has a verb action to configure as well as reconfigure thevocabulary, the Thing Machine can learn, examples of which are providedherein.

Referring to an exemplary RDF Thing, described herein for illustrativepurposes, the following exemplary definitions apply.

Graph—a collection of points and lines connecting some (possibly empty)subset of them. The points of a graph are most commonly known as graphvertices, but may also be called “nodes” or simply “points.” Similarly,the lines connecting the vertices of a graph are most commonly known asgraph edges, but may also be called “arcs” or “lines.”

A graph node is referred to as a graph:node. A graph edge is referred toas a graph:edge. An edge can have a label, referred to as agraph:edge-label(label).

Directed Graph—A directed graph is graph, i.e., a set of objects (calledvertices or nodes) that are connected together, where all the edges(directed graph edges) are directed from one vertex to another.

A directed graph is sometimes called a digraph or a directed network.

A directed graph is referred to as a graph:directed.

A directed graph edge is referred to as a graph:directed-edge.

Undirected Graph—An undirected graph is graph, i.e., a set of objects(called vertices or nodes) that are connected together, where all theedges (undirected graph edges) are bidirectional. An undirected graph issometimes called an undirected network. An undirected graph is referredto as a graph:undirected. An undirected graph edge is referred to as agraph:undirected-edge.

Subgraph—A subgraph is a graph whose vertices and edges are subsets ofanother graph.

Rooted Graph—A rooted graph is a directed graph wherein one node isdistinguished as the starting (root) node.

In accordance with the present system and method, ABNF is used todescribe a representation of a non-mutable component of a Thing asadministered by P(TM(thing)) In addition, RDF is used to furtherillustrate the meaning of a non-mutable and mutable components of aThing as administered by P(TM(thing)).

ABNF

In the exemplary illustration provided herein, the augmented backus-naurform (ABNF) specification, as illustrated hereinafter, is used todescribe a Thing as administered by P(TM(thing)). Specifically, thefollowing describes a Thing and its non-mutable components, asadministered by a P(TM(thing)).

-   -   scheme: scheme-name=ALPHA*(ALPHA/DIGIT/“+”/“−”/“.”)    -   scheme:scheme-specific-part=this is scheme specific. See the RFC        corresponding to the scheme name for details on the scheme        specific part. If no such RFC exists, then the        scheme-specific-part is parsed into Thing identifiers as defined        by the Thing Language. Otherwise, the scheme-specific-part is        tokenized according to the scheme.

The following ABNF rules apply.

-   -   thing:identifier=1*1        (scheme:scheme-name/scheme:scheme-specific-part)    -   thing:char-literal=char-val    -   thing:num-literal=num-val    -   thing:bin-literal=bin-val    -   thing:dec-literal=dec-val    -   thing:hex-literal=hex-val    -   thing:value=1*(thing:char/thing:num/thing:bin/thing:dec/thing:hex)        A class id identifies a class of things. The default class id is        a URI and the Thing identified by the URI is the classification.        The default is thing:thing.    -   thing:class.id=URI    -   A thing:set(i) is a set of things that are i. The generic set is        thing:set.of(thing:thing) which is a set of things. A set has no        duplicate named things.    -   thing:set.of(i)=0,*(i)    -   A thing:list(i) is a list of things that are members of class i.        The generic set is thing:list.of(thing:thing) which is a list of        things. A list may have duplicate (i).    -   thing:list.of(i)=0,*(i)    -   NOTE: in an embodiment, a parameter can be referenced as        thing:value.of(i), thing:name.of(i),        thing:thing(thing:name.of((thing:value.of(i))), and so on.

Thing RDF

The Resource Description Framework (RDF) is a framework for representinginformation in the Web. An RDF triple consists of three components: a)the subject, which is an IRI or a blank node; b) the predicate, which isan IRI; and, the object, which is an IRI, a literal or a blank node. AnRDF triple is conventionally written in the order subject, predicate,object. An RDF graph is a set of RDF Triples.

RDF triples are used in the following section to describe a Thing, andin a Thing graph, the predicate denotes a relationship type between thesubject and the object. The thing:is-a relationship type denotes thatthe subject is a member of the class of things identified by the object.The thing:has-a relationship type denotes that the subject has anon-mutable component given by the object. Note the value of a componentcan change, but the component cannot. See relationship types for detail.

A reference P(TM(i)) is a reference to the algorithmic Procedure of aThing Machine sub-i where i is an identifier that qualifies a firstProcedure of a Thing Machine from a second Procedure of a Thing Machine.

A Thing is a node in a graph as administered by P(TM(thing)).

thing:thing thing:is-a graph:node

A Thing has a name, a value, class, and relationship-set. In a preferredembodiment providing backward compatibility for the world wide web, anamespace thing name is a scheme:name. The P(TM(thing)) can set, get, orunset Things.

thing:thing thing:has-a thing:name thing:thing thing:has-a thing:valuething:thing thing:has-a thing:class.id thing:thing thing:has-athing:relationship-set thing:name thing:is-a thing:identifier

The following rule denotes that a relationship-set is comprised of zeroor more relationships. A relationship-set with zero relationships is anempty set. A rooted thing:graph of a thing:thing with a relationship-setthat is an empty set, is an empty graph (a thing:graph.empty) of thething:thing.

-   -   thing: relationship-set=thing:set.of(thing:relationship(s,r,o))

In the following rule s, r, and o are parameters that denote that: Thereexists a relationship-type(r) between thing:subject(s) andthing:object(o). The P(TM(thing)) can set, get, or unset a relationship.

-   -   thing:relationship(s,r,o)=thing:subject(s)        thing:relationship-type(r) thing:object(o)

The following rule is to be interpreted as: There is a thing where nameis equal s.

-   -   thing:thing(s)=thing:thing where        is:equal.to=(thing:name.of(thing:thing), (s))

The following rule is to be interpreted as: There is a thing where nameis equal s and value is equal to v.

-   -   thing:thing(s,v)=thing:thing where        (is:equal.to=(thing:name.of(thing:thing), (s)) and        is:equal.to=(thing:value.of(thing:thing), (v)))

In an embodiment, components of the thing can be referenced. Thefollowing rule for example is interpreted as there is a Thing [where[name=a] and [value=b].

-   -   thing:thing(0,1[name=a] 0,1[value=b])=thing:thing where is: (s))        and is:equal.to=(thing:value.of(thing:value), (v))

thing:subject thing:is-a thing:thing thing:subject(s) thing:is-athing:thing(s) thing:object thing:is-a thing:thing thing:object(o)thing:is-a thing:thing(o)

In the following rule(s,c,o) are parameters that denote that the claimgiven by c, is satisfied by (s) and the optional thing:object(o). AsThings, the rule is interpreted as There is a subject Thing (s) suchthat, there is a satisfaction claim c, such that, there is an optionalobject(o).

-   -   thing:assert(s,c,o)=*(thing:subject(s) thing:predicate(c)        thing:object(o))

The following rule equates to the value of the name component of thething given by parameter (i)

-   -   thing:name.of(i)=thing:value.of((i):name)

The following rule equates to the value of the value component of thething given by parameter (i)

-   -   thing:value.of(i)=thing:value.of((i):value)

The following are exemplary relationship types(thing:relationship-type).

thing:is-a Subject thing is a member of the class denoted by the object.thing:has-a Subject thing has a non-mutable component identified by theobject.

-   -   thing:sttia There is a subject thing, such that, there is an        object thing

thing:sttiai There is a subject thing, such that, there is an instanceof object thing. thing:sttmb There is a subject thing, such that, theremay be the object thing. thing:sttina There is a subject thing, suchthat, there is not an object thing. thing:parent The object thing is theparent of the subject thing. thing:child The object thing is the childof the subject thing.

-   -   thing:next The object thing is the next sibling of the subject        thing.

thing:prior The object thing is the prior sibling of the subject thing.

The thing:is and thing:is.not assertions are thing:predicatesatisfaction claims. A satisfaction claim may be in the form of anexpression given by:

-   -   thing:expression=thing: subject thing:satisfaction-claim        0,1(thing:object)

A satisfaction claim is asserted by a thing:verb that acts upon theclaim. This enables the set of accessible satisfaction claims to beself-configured for the particular embodiment. A subset of satisfactionclaims include:

thing:is.lt The value of the subject thing is less than the value of theobject thing. thing:is.lteq The value of the subject thing is less thanor equal to the value of the object thing. thing:is.eq The value of thesubject thing is equal to the value of the object thing. thing:is.gteqThe value of the subject thing is equal to or greater than the value ofthe object thing. thing:is.gt The value of the subject thing is greaterthan the value of the object thing. thing:is.not.empty The value of thesubject thing is not empty.A thing:graph(s) is a graph of thing:subject(s). The thing:graph(monad)is a supergraph of related Things.

thing:directed-edge thing:is-a graph:directed-edgething:directed-edge(s,r,o) thing:is-a graph:directed-edge withgraph:edge-label(r) of thing:relationship(s,r,o) thing:blank.nodething:is-a thing:thing thing:rgraph(s,r,o) = thing:subject(s )thing:directed-edge(s,r,o) thing:object(o) thing:graph.empty(s) =thing:subject(s) thing:graph(s,r,o) = thing:rgraph(s,r,o) /thing:graph.empty(s)The thing:class(class.id) is a thing:thing given by the thing:nameclass.id. It has a relationship to a discipline that exists within thecontext of that class.

thing:class(class.id) thing:is-a thing:subject(class.id)thing:class(class.id) thing:has-athing:relationship(thing:class(class.id), thing:sttia,thing:discipline(class.id,d)) thing:class(class.id) thing:has-athing:relationship(thing:class(class.id), thing:sttia,thing:binding.urr) thing:discipline(class.id,d) thing:is-athing:context(thing:class(class.id), thing:verb(d)) thing:class(c)thing:may-have-a thing:relationship(thing:class(c),thing:sttia,G.criteria(c)) G.criteria(c) thing:is-a thing:graph denotingthe set of criteria for being a member of the thing:classExemplary thing:class include

-   -   a) thing:class(thing:char)    -   b) thing:class(thing:num)    -   c) thing:class(thing:bin)    -   d) thing:class(thing:dec)    -   e) thing:class(thing:hex)        Exemplary disciplines include    -   a) thing:discipline(c, thing:set)    -   b) thing:discipline (c, thing:get)    -   c) thing:discipline (c, thing:unset)        An embodiment can add a set of modifiers to modify the        P(TM(discipline(c,d)). Exemplary Modifiers include:    -   a) thing:before(thing:discipline(c,d),thing.urr(u))    -   b) thing:as(thing:discipline(c,d),thing.urr(u))    -   c) thing:after(thing:discipline(c,d),thing:urr(u))        A thing:before urr is evaluated before the        thing:discipline(c,v), and if satisfied, then the        thing:discipline(c,v) is evaluated.        A thing:as urr is evaluated as if it were the G(urr(d)).        A thing:after urr is evaluated after the successful evaluation        of the G.urr(d) or the thing:as urr if specified.

A new classification is configured by configuring the classthing:class(class.id) graph with appropriate relationship(s) todiscipline(s).

A thing:verb is a thing:thing administered by P(TM(thing)), such thatthere is a representation of a reference to a performable action thatcan be resolved to a performable action that P(TM(perform)) can causeperformance of. P(TM(perform)) is said to perform the thing:verb bycausing performance of the performable action.

thing:verb(i) thing:is-a G(P(TM(i))) G(P(TM(i))) thing:is-athing:subject(i) G(P(TM(i))) thing:has-athing:relationship(thing:subject(i), thing:sttia,G(request(i)))G(P(TM(i))) thing:has-a thing:relationship(thing:subject(i),thing:sttia,G(urr(i))) G(request(i)) thing:is-a thing:graph of thethings P(TM(i)) can act upon G(urr(i)) thing:is-a thing:graph of athing:urr(i)

The thing:urr(i) is a Uniform Resource Request for requestingperformance of a P(TM(i)). A P(TM(i)) action binds the value of thething:urr(i) to a performable action that the P(TM(perform)) canperform. In an exemplary embodiment this can include binding to anaddress of an instruction in non-transitory memory, and the embodimentmay further be characterized by the use of one or more operating systemcalls, such as fork, exec, pthread_create, connect, open, send, write,receive, read, close, wait, and/or disconnect.

In evaluating a request to perform a P(TM(i)), the P(TM(eval)) interactswith P(TM(thing)) to determine the P(TM(i)) algorithmically prepare agraph of P(TM) things that need to be accessible to P(TM(i)). In oneembodiment, said graph is generated in the context of a requestnamespace specifically generated for the duration of P(TM(i)) action,and the response, if any, is set in the context of a response namespace.This enables P(TM(eval)) to push a new context onto the context stackfor P(TM(i)) and algorithmically interact with the response namespace toupdate Things administered by P(TM(thing)) accordingly.

A thing:verb.vocabulary is a thing:thing such that there is arelationship to a set of thing:verbs.

thing:verb.vocabulary (c) thing:is-a thing:subject(c)thing:verb.vocabulary (i) thing:has-a thing:relationship(thing:subject(i),thing:sttia,thing:set.of(thing:verb) )thing:verb.vocabulary (i) thing:has-a thing:relationship(thing:subject(i),thing:sttia,G(urr(i)) ) G(urr(i)) thing:is-athing:graph of a thing:urr(i)

The corresponding performable action of thing:urr(i) is performed by aP(TM(i)) to configure the verb Things for the verb vocabulary.

exemplary Thing:relationship

The following further illustrates an embodiment of Thing relationships.As shown by the directed graph of FIG. 19 , the Thing named x is thepredecessor of the Thing named y, y is the successor of the Thing namedx, and, the predicate is the thing such that there is a relationship,which is denoted as thing:sttia. The English interpretation is: There isa Thing where name is equal to x, such that, there is a Thing where nameis equal to y. The “such that there is a” relationship is denoted by thething:sttia edge label.

As shown by the directed graph of FIG. 20 , the Thing named x is thepredecessor of the Thing named z, and the predicate is “such that thereis an instance”, which is denoted as thing:sttiai. The Englishinterpretation is: There is a Thing where name is equal to x, such that,there is an instance of a Thing where name is equal to z.

As shown by the directed graph of FIG. 21 , the English interpretationis given as: There is a Thing where name is equal to x, such that, thereis a Thing where name is equal to y, such that, there is a Thing wherename is equal to z, such that, there is a reference to a Thing wherename is equal to x. The such that there is a reference to relationshipis denoted by the thing:sttiart edge label. The reference can be in theform a URI which can be interpreted as a listing.

As shown by the directed graph of FIG. 22 , the Thing named x is athing:table. Using next and last edge pairs, and parent child edgepairs, the graph can be traversed in either direction.

As shown by the directed graph of FIG. 23 , a multiplicity of Thingshave a relationship to a single Thing.

As shown by the directed graph of FIG. 24 , the Thing named “x” is amember of the class of Things named “c”.

A predicate can denote a relationship about a non-mutable component of aThing. As shown by the directed graph of FIG. 25 , the relationshipdenotes that the name of the Thing named “x” is a member of the class ofThings named “b”.

As shown by the directed graph of FIG. 26 , the relationship denotesthat the value of the Thing named “x” is a member of the class of Thingsnamed “c”.

The following are exemplary Things administered by P(TM(thing)) in theadministration of Things in the graph.

thing:monad—the monad is the first Thing from which all other Thingsadministered by the P(TM(thing)) can be identified. The nodes of thedirected graph are Things, and a directed edge label is a propositionthat holds between the connected Things The monad directed graph denotesthe state of the Thing Machine. The monad is connected with an edgedirected to a context Thing with the directed edge label “such that,there is a” which is denoted as “thing:sttia”.

thing:context—the context Thing is representative of a set of Thingsorganized as a stack, wherein the top of the stack is the Thingrepresentative of the current context. A new context Thing may bealgorithmically pushed onto the stack, or algorithmically popped off ofthe stack, to change the current context. An instance of a context Thingis a root of a directed graph of a set of Things that are Namespaceswithin the scope of that context.

thing:namespace—a namespace is a Thing that represents a named graph ofsomehow logically related Things, even if related simply by beingmembers of the same namespace. The name of the graph conforms to thenaming requirements of an International Resource Identifier (IRI)scheme. The rooted directed graph of the namespace starts with theNamespace Thing as the root, and the connected nodes are Things that arequalified by the Namespace Thing. The directed edge labels denote arelationship that holds between the connected Things.

The context Thing quantifies the set of available namespace Things.Exemplary namespaces include the request, response, local, service,core, and boot namespace. Additional namespaces can be configuredthrough the action of the P(TM(thing)). The following graph is true foreach namespace of context, where the unnamed node of the graph is boundto a namespace qualified by the context. As shown by the directed graphof FIG. 27 , the context includes a request, a response, and, a localnamespace. An embodiment can self-configure the set of namespaces.

Exemplary namespaces are provided by table 3 below.

TABLE 3 Namespace Use about: The Things in the about: namespace areinternal resources, such as settings, copyright information, licensing,component lists, and other such resources used by the Thing Machine. Thenamespace and the naming of Things conforms to the “about” URI scheme asdescribed in RFC6694 boot: The Things in the boot: represent the bootstate, including the boot verb vocabulary. core: The Things in the core:namespace represent the state of the core vocabulary including coreverbs. The core verb vocabulary is used construct the application model.local: The Things in the local: namespace represent temporary stateinformation. The local: namespace has local scope. request: The Thingsin the request: namespace represent the current request. response: TheThings in the response: namespace represent the response to the currentrequest.

Mapping an IRI to a Namespace Thing

The IRI scheme name is mapped to a Namespace THING, and the schemespecific part of the IRI is then mapped according to the rules of theparticular namespace. The default behavior is to use the dot (“.”)character delimiter to denote “such that there is a” relationships, andthe bracket delimiters (“[” and “]”) to denote “such that there is aninstance of” relationships. For example, the reference:

-   -   request:statement[1].word is interpreted as:        -   There is a NAMESPACE THING where Name is equal to “request”,            such that, there is a THING where Name is equal to            “statement”, such that, there is an instance of a THING            where Name is equal to “1”, such that, there is a THING            where Name is equal to “word”.

As mentioned in the THING Graph Data Model section, all permanent URISchemes, as published by the Internet Assigned Numbers Authority, arereserved namespace names. The complete list of reserved namespaces ispublished online at iotnamespaces.com/reserved. The mapping of IRIs toreserved namespaces is also available at iotnamespace.com/mappings.

Identifying Things Using XML

Basic XML is parsed and bound in a namespace. This is important forservices such as the weather service identified by the URLhttp://wl.weather.gov/xml/current_obs/index.xml, which use basic XMLformat. To illustrate the mapping, consider the fragment given as:

 <station>  <station_id>PADQ</station_id>   <state>AK</state> <station_name>Kodiak, Kodiak Airport</station_name>  <latitude>57.75</latitude>   <longitude>−152.5</longitude>  <xml_url>http://weather.gov/xml/current_obs/PADQ.xml</xml_url></station>Upon parsing the simple XML, the following triples are true asillustrated by table 4.

TABLE 4 Subject Predicate Literal Value Station THING:equals “”station.station_id THING:equals PADQ station.state THING:equals AKstation.station_name THING:equals Kodiak, Kodiak Airportstation.latitude THING:equals    57.75 station.longitude THING:equals−152.5 station.xml_url THING:equals http://weather.gov/xml/current_obs/PADQ.xml

In basic XML mapping, elements are mapped to THINGs, and attributes aremapped as instances of attributes of that THING.

XML Schema Definitions

From our prior example using weather station XML data, the local:station.xml_url THING has a value that identifies a resourcerepresenting the station's local data. In retrieving that resource, wefind it is an XML version 1.0 document that contains, in part:

<current_observation version=“1.0” xmlns:xsd=“http://www.w3.org/2001/XMLSchema” xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”xsi:noNSL=“http://www.weather.gov/view/current_observation.xsd”>

In parsing the XML, the default action interprets the element as aTHING, and the attributes as instances of attributes about that THING.The following triples are true, as illustrated in table 5.

TABLE 5 Subject Predicate Object current_observation[version]THING:equals 1.0 current_observation[xmlns:xsd] THING:equalshttp://www.w3.org/2001/XMLSchema current_observation[xmlns:xsi]THING:equals http://www.w3.org/2001/XMLSchema-instancecurrent_observation[xsi:noNS] THING:equalshttp://www.weather.gov/view/current_observation.xsdAs a formal assertion, the triples can be expressed as:

There is a THING where Name is equal to “current observation”, suchthat,

There is an instance of a THING where

-   -   Name is equal to “xmlns:xsd” and    -   Value is equal to “http://www.w3.org/2001/XMLSchema”,

and,

There is an instance of a THING where

-   -   Name is equal to “xmlns:xsi” and        -   Value is equal to            “http://www.w3.org/2001/XMLSchema-instance”,    -   and,        -   There is an instance of a THING where    -   Name is equal to “xsi:noNamespaceSchemaLocation” and    -   Value is equal to        -   “http://www.weather.gov/view/current_observation.xsd”.

The XSD reference enables retrieving the XSD schema, so that a validstructure of the object element, sub-elements, and attributes can thenbe represented as THINGs in a Namespace.

XML Namespaces

In XML, a qualified name is a name that is subject to namespaceinterpretation. Both elements and attributes are qualified names. Whenparsing an XML document adhering to the XML Namespace specification, thedocument is parsed into the request Namespace, validated, and retainsthe structure of the document using the qualified names as THING names.

Consider, for example, the XML document given below. The book elementsincludes two namespace attributes; the first defining the default XMLnamespace, and the second defining the isbn XML namespace. The XML 1.1specification does not require the IRI to be verified IRIs, but ratherspecified as a syntactically correct IRI. As such, the parses actiondoes not map the XML IRI references to THING namespaces.

 <?xml version=“1.0”?>  <book xmlns=‘urn:loc.gov:books’  xmlns:isbn=‘urn:ISBN:0-395-36341-6’>  <title>Cheaper by theDozen</title>  <isbn:number>1568491379</isbn:number>  <notes>  <!-- makeHTML the default namespace for some commentary -->  <pxmlns=‘http://www.w3.org/1999/xhtml’>   This is a <i>funny</i>book! </p>  </notes> </book>Using the shorthand notation, the following are true, as illustrated bytable 6.

TABLE 6 request:book[xmlns] THING:equals urn:loc.gov:booksrequest:book[xmlns:isbn] THING:equals urn:ISBN:0-395-36341-6request:book.title THING:equals Cheaper by the Dozenrequest:book.isbn:number THING:equals 1568491379request:book.notes[xmlns] THING:equals http://www.w3.org/1999/ xhtmlThe formal satisfaction claims are

There is a Namespace THING where Name is equal to “request”, such that,

-   -   there is a THING where Name is equal to “book”, such that,        -   there is an Instance where            -   Name is equal to “xmlns” and            -   Value is equal to “urn:loc.gov:books”, and,        -   there is an Instance where            -   Name is equal to “xmlns:isbn” and            -   Value is equal to “urn:ISBN:0-395-36341-6”.

Thing Language

In the THING graph model, all things are Things. Some THINGS arenamespaces, some are verbs, and other THINGS are the THINGS that theverb actions can act upon. The relationship between the verb and the setof THINGS the verb can act upon is expressed as a THING verb graph.

Classification enables the meaning of the intended action to beinferred. In the following example statements the intended action is to“set” something using a THING and a unit of time; however, the requiredaction per statement is very different.

-   -   Set the timer to 6:00 minutes.    -   Set the clock to 6:00 AM.    -   Set the alarm for 6:00 PM.

A parsing action is performed to parse a statement as a thing:graphTHING graph. The evaluate verb evaluates the thing:graph in the contextof the verb vocabulary graph, to select a candidate verb. The evaluateverb action binds the THINGS in the request graph to the THINGS S in thecandidate verb graph to identify the instance of the verb graph thatneeds to be performed. The perform action is triggered to cause theidentified verb action to be performed in the context of the boundTHINGS.

Thing Statements

The Thing Language offers both imperative and declarative statementstructures. In a general sense, the minimal boot vocabulary lends itselftoward the use of imperative statements, whilst the more expressive corevocabulary enables the use of declarative statements. The ABNFdefinition for a Thing statement is provided below. The ABNF syntax isdefined in RFC2234.

-   -   thing:statement=statement-1/statement-2    -   statement-1=ne-pair    -   statement-2=listing expression [“;”]    -   nv-pair=listing=DQUOTE value DQUOTE [“;”]    -   ne-pair=listing=OP expression CP    -   expression=*(ne-pair/nv-pair)    -   listing=namespace “:” namespace-specific-part    -   OP=“(”    -   CP=“}”    -   DQUOTE=“′”

As an example, the following imperative statement instructs the ThingMachine to set the Thing identified by the listing request:my.name tothe value John.

-   -   set=(requesturi=“request:my.name” request:value=“John”)

The P(TM(bind)) action can be used to bind listings to Things that anaction can act upon so that the above statement could be specified as:

-   -   set=(request:my.name=“John”)

In general, the same syntax applies to any statement in the THINGlanguage. Note that the THINGS that the verb action can act upon arecontained with the “(” and “)” delimiters.

  set=( request:uri=”local:counter” request:value=”1” ) while=( condition=(    is.less.than=(      request:uri=”local:counter”     request:value.of=”local:max.value”    )  )  action=(    increment=(     request:listing=”local:counter”    )  ) )

The simple syntax of the THING language translates easily to otherlanguages. For example, the above statement can be expressed in JSON, asshown below.

  {  “set”: {    “request:listing”: ”local:counter”,    “request:value”:”1”  },  “while”: {    “condition”: {      “is.less.than”: {       “request:listing”: ”local:counter”,        “request:value.of”:“local:max.value”      },    }    “action”: {      “increment”: {       “request:listing”: ”local:counter”      }    }  } }

Similarly, the example statements can be expressed using THING/XML.

  <set>  <request:listing>local:counter</request:listing> <request:value>1</request:value> </set> <while>  <condition>   <is.less.than>     <request:listing>local:counter</request:listing>    <request:value.of>local:max.value</request:value.of>   </is.less.than>  </condition>  <action>    <increment>   <request:listing>local:counter</request:listing>    </increment> </action> </while>

Any number of languages and syntax can be used, as long as the parseraction can parse the data into a thing: graph.

Multipart data is supported, as shown below. In this example we presenta simple statement based on the set verb. Note that request:listing isnot specified. The evaluate verb action will interact with the request:graph, and the corresponding verb graph in the verb vocabulary, to bindTHINGS in the request: graph to THINGS that the verb can interact with.In this example, the value of request:listing defaults to rcd:Contact,and the value of the request:class defaults to thing:thing.

  set=(  rcd:Contact=(    Name=(      Last=”Amrit”      First=”Vivaan”   )    Email=”v.amrit@iotnamespace.com”    Status=”pending”  ) )

The above statement is equivalent to:

  set=(  request:listing=”rcd:Contact.Name.Last”  request:value=”Amrit” request:class=”thing:thing” ) set=( request:listing=”rcd:Contact.Name.First”  request:value=”Vivann” request:class=”thing:thing” ) set=( request:listing=”rcd:Contact.Email” request:value=”v.amrit@iotnamespace.com”  request:class=”thing:thing” )set=(  request:listing=”rcd:Contact.Status”  request:value=”pending” request:class=”thing:thing” )

A declarative statement follows the same general syntax as an imperativestatement. To illustrate the differences, we will start with a simpleexample using three imperative statements to initialize the listingpainting:Gallery as an auto-instanced THING. A THING that is classifiedas thing:auto-instance, will have a new instance automatically addedeach time the THING is used in a set verb action.

  set=(   request:listing=”painting:Gallery”  request:class=”thing:auto-instance”   Name=” Zhang Daqian   Title=”PeachBlossom Spring” ) set=(   request:listing=”painting:Gallery”   Name=”VanGogh”   Title=” Almond Blossom” ) set=(  request:listing=”painting:Gallery”   Name=”Ylli Haruni”   Title=”CherryBlossom” )

The following declarative statement is then used to express what wewant, without detailing each step required.

  evaluate=(  using=(   request:instances.of=”painting:Gallery”  request:as=”gallery:”  )  for.each.time=(   condition=(    is.like=(    request:listing=”gallery:Title”     request:pattern=”{circumflexover ( )}.*Blossom$”    )   )  )  perform=(   display=(   listing[1]=”gallery:Name”    listing[2]=”gallery:Title”   )  ) )The output of the above is given as:

Van Gogh Almond Blossom Ylli Haruni Cherry Blossom

Namespace Scope

A namespace is a THING that represents a named graph of somehowlogically related THINGs, even if related solely by being members of thesame namespace. Namespaces THINGs are qualified by the context THING,and the name of the graph (the name of the Namespace) conforms to thenaming requirements of an IRI scheme. All permanent URI Schemes, aspublished by the Internet Assigned Numbers Authority, are reservednamespace names.

Classifications

THINGs can be classified as being a member of a class of THINGs. AllTHINGs are THINGs. Some THINGs are integers, some are floats, and someare sets, and so on. The Namespace system self assembles with a Set ofCore Classes, upon which additional classes can exist. Chapter 2provides detailed information on classes.

The following example is interpreted as: perform the set action so thatthere is a THING where Name is equal to local, and, this THING is anamespace, such that, there is a THING where Name is equal to scores. Inthis context, scores is a THING.

-   -   set=(listing=“local:scores”)        The following example describes a request to set scores as a        floating point number.    -   set=(class=float listing=“local:scores” value=“83.25”)

Communication Primitives

A communication Primitive is a THING that provides an interface forcommunicating. Primitives enable common actions such as connect, send,receive, and disconnect. Communication Primitives for various types ofcommunication are provided include web THINGS, sockets, files, RS232,URI schemes, and Uniform Resource Request listing.

Communication Points

A communication point is a THING that a communication primitiveinteracts with to cause communications to occur.

Regular Local Files

-   -   connect=(listing=file://—/mydocumentsiscores.txt as=compoint:1)    -   send.line=(compoint=“compoint:1” value=“93”)    -   send.line=(compoint=“compoint:1” value=“87”)    -   send.line=(compoint=“compoint:1” value=“92”)    -   close=(compoint=“compoint: 1”)

Using Unencrypted Standard Email

-   -   connect=(listing=“email:johnkingburns@gmail.com” as=compoint:2)    -   send=(compoint=“compoint:2” value=“Subject: Meeting”)    -   send=(compoint=“compoint:2” value=“John, let's meet on Tuesday        at 10:00 am to discuss the plan.”)    -   close=(compoint=“compoint:2”)

Using Encrypted Active Namespace

-   -   connect=(listing=“activeNamespace:john.king.burns”        as=“compoint:jkb”)    -   send=(compoint=“compoint:jkb” value=“Subject: Meeting”)    -   send=(=“compoint:jkb” value=“John, let's meet on Tuesday at        10:00 am to discuss the plan.”)    -   close=(=“compoint:jkb”)

Statements

In the THING Language a statement includes a verb and zero or moreObject name=expression pairs. Each expression is a value expression or aname=expression pair. The binder can bind dot delimited verb modifiers.

-   -   verb[modifier[modifier]] name_expression    -   name_expression:name=“(” name_expression|value_expression “)”    -   value_expression: quote literal end_quote        -   :literal        -   :“(” mathematical_expression “)”

A name expression is quantified by the name containing the nameexpression. Thus a=(b=1) is interpreted as: There is a THING where nameis equal to a, such that, there is a THING where name is equal to b andvalue is equal to 1. A multipart statement, such as a=(b=1 c=2) isinterpreted as: There is a THING where name is equal to a, such that,there is a THING where name is equal to b and value is equal to 1, and,there is a THING where name is equal to c and value is equal to 2.

A value expression is a literal and it may be quoted. A literal valueincluding a space character must be quoted. Thus, a=house, a=“house”,a=‘house’ are equivalent. Similarly, a=“red house” and a=‘red house’ areequivalent.

A mathematical expression is enclosed in double parentheses, and neednot be quoted. As an example a=((10+−2*(6/3))). Normal orders ofoperations apply, and expressions may be enclosed with parenthesis.Functions are not supported, but math verbs are. Thus, a=((2*sqrt(4)))would be evaluated as one would expect as long as sqrt is a verb in themath verb vocabulary.

To explicitly represent a statement, the format is:

-   -   statement=(verb_expression Object_expression)    -   modifier_exprssion:“.” modifier modifier_expression        -   :modifier    -   verb_expression:verb modifier_expression        -   :verb    -   Object_expression:name_expression Object_expression        -   :name_expression

Action Blocks

An Action Block is a sequence of statements to be evaluated as a unit.This enables the Namespace System to perform the block and allow thelogic to address true and false type statements. The general syntax ofan action block is:

  action block=(  statement-1  statement-2  action=(   . . .  ) statement-n )

In the following example, a simple action block sequence is provided in

• action=(  set=( listing=”local:counter” value=”1” )  print=(listing=”local:counter” ) )

Conditionals

The Namespace System provides for conditional evaluations of an action.IF, ELSE-IF, and ELSE conditionals are supported.

• if=( condition=( is.less.than=( listing=”local:number” value=’10’ ))   action=( increment=( listing=”local:number” ))) else.if=( condition=(is.less.than=( listing=”local:number” value=’20’ ))      action=(increment=( listing=”local:number” by.value=”2” )))else=(action=(break))

Iteration

Iteration is enabled by the for and while.condition verb actions.

•  for=(   condition=(    is.less.than=( lhs=”local:number” rhs=’5’)   )  action=(    increment=(var=”local:number)   )  ) •  while=(  condition=( is.less.than=( lhs=”local:number” rhs=’5’)   action=(   (increment=(var=local:number)   )  ) set

The set verb action will set the THING, given by the value of therequest:listing according to the rules of the classification identifiedas the value of request:class. When the class is not explicitlyspecified, then the evaluate verb action will determine an appropriateclassification based on the Things in the statement.

In the following statement, the classification defaults torequest:class=“thing:thing”, and the corresponding verb graph is shownin FIG. 28 .

   set=(   request:listing=listing   request:value=expression )

In the following statement, the classification defaults torequest:class=“thing:alarm”, and the corresponding verb graph is shownin FIG. 29 .

   set=(   request:listing=listing   request:time=time )

A verb statement for the set is shown here. As new classifications areadded, additional verb actions may be necessary to support the meaningof the classification, and these may be added to the vocabulary usingverb modifiers.

   set=(   request:listing=listing   request:value=expression  request:class=class )

thing:graph—A thing:graph is a directed graph of a Thing and its relatedThings, and may be expressed as a sub-graph of all possible Things andtheir relationships from a root directed graph. An unnamed vertex labelis interpreted as the thing:identifier. Otherwise, one or more namednon-mutable components and representations may be used as the vertexlabel. In the preferred embodiment, Name: name, and Value: value, areused to denote the thing:identifier, and thing:value, respectively, whensuch distinction is required.

An unnamed vertex in a thing:graph, is the set of Things in the domainof discourse, qualified by the predecessors of the unnamed vertex ifany, that satisfy the unnamed vertex directed graph.

-   -   thing:subgraph—A P(TM(i)) may act upon a thing:subgraph of the        monad rooted directed graph    -   thing:statement—a thing:graph representative of a statement to        evaluate.    -   thing:statement.declarative—a declarative thing:statement.    -   thing:statement.imperative—an imperative thing:statement.    -   thing:statement.interrogative—an interrogative thing:statement.    -   thing:statement.exclamatory—an exclamatory thing:statement.    -   thing:listing—a listing is a representation of a reference to a        Thing. A qualified listing includes a representation of a        reference to a namespace, and has the general format        “namespace:namespace-specific-part”, the format is comparable to        a URI comprised of a “scheme:scheme-specific part”. An        unqualified listing (also referred to as an unbound listing),        can be algorithmically qualified by P(TM(bind)). A thing:listing        is resolved by the algorithmic action of P(TM(thing)).

The namespace-specific-part can be resolved through the use of get, set,and unset disciplines for a given namespace. This enables thepredictable algorithmic action to resolve a reference, even when theinterpretation of the namespace-specific-part is dependent on thenamespace being modeled.

Free Variables

A representation of a reference to a Thing is considered a freevariable. The P(TM(bind)) algorithmically binds the reference within theset of Things defined by the context. In traversing the thing:graph, thecontext of Things is algorithmically updated to reflect those Thingsthat are applicable in the current scope of Things within the domain ofdiscourse. Consider the following assertion:

-   -   There is a Thing, such that, there is a Thing where name is        equal to Contact, and, there is a Thing where name is equal to        Email.

The opening reference “There is a Thing, such that” indicates that allpossible Things in the domain of discourse administered by P(TM(thing))are considered in the current set of Things. The P(TM(bind)) thendisqualifies all such Thing in the current set for which the limitation“such that, there is a Thing where name is equal to Contact, and, thereis a Thing where name is equal to Email” does not hold.

Referring to FIG. 30 , G.request(P(TM(i))) indicates that P(TM(i)) canact upon a Thing qualified in the request namespace. The unnamed nodedenotes that the P(TM(i)) can act upon some Thing qualified in therequest namespace, without identifying the Thing by name.

Referring to FIG. 31 , G.request(P(TM(i))) indicates that P(TM(i)) canact upon a Thing named Contact that is qualified by a Thing namedstatement, that is qualified in the request namespace.

Referring to FIG. 32 , the exemplary G(P(TM(i))) is a rooted directedthing:graph that includes a G.request(P(TM(i))) subgraph, and, aG.urr(P(TM(i))) subgraph denoting how P(TM(perform)) is to request theP(TM(i)) to perform its action. Note that the components of therequest:statement.Thing satisfy the components of a Thing schema asdefined by http://www.schema.org/Thing.

Uniform Resource Request

A Uniform Resource Request (URR) Thing is a URI that can be interpretedby P(TM(thing)) as a request for a performable action to be performed.By way of example:

-   -   stdlib:load///usr/local/lib/libboot.so?entry=‘init’    -   http:get//www.iotsystems.com/index.hml    -   http://www.iotsystem.com/index.html    -   task:list.my.contacts?request:pattern=‘[A-M].*’

The distinction between a URR and a conventional URI is that a URR isevaluated in the context of Things in a thing:namespace instead of arequest for a server to provide an identified resource.

The stdlib:load Thing is an Active Thing whose performable actiondynamically loads the corresponding library, resolves a reference to thevalue of the entry Thing as a performable actions, and performs thataction. The action is typically embodied using dlopen( ) and dlsym( )calls, or equivalent calls on the Windows, Linux, BSD, iOS, or othersuch operating systems. Seepubs.opengroup.org/onlinepubs/009695399/functions/dlopen. The responsefrom the performance of the action is a set of thing:statementsrequesting the Thing Machine configure thing:verbs correlating to theloaded actions. P(TM(bind)) can be used to bind entry point referencesto performable actions using the dlsym( ) or equivalent operating systemcall.

The stdlib:unload Thing is an Active Thing whose performable actionunloads the corresponding library. The action is typically embodiedusing dlclose. Seepubs.opengroup.org/onlinepubs/009695399/functions/dlclose. Care must betaken to note the distinction between client and server resourceresolution when using URR versus URI, with the former being resolved toa resource by the Thing Machine, versus the latter commonly beingresolved to a resource by a server.

A P(TM(i)) can generate a URR and request the P(TM) to evaluate andperform an appropriate action. As an example, a P(TM(parse)) caninteract with content to parse, and discover it is in a format orlanguage the parser action does not understand. In such cases, theP(TM(parse)) can request the evaluation and performance of a secondP(TM(i)) action that may be able to parse the content.

A first Thing Machine with communication capability can communicate arequest to a second Thing Machine to identify a Thing (or the contentsthereof). A second Thing Machine can teach the first Thing Machine whatsomething represents; actions that can act upon it; and/or tasks thatcan be performed using it.

Core POSIX Vocabulary

Core POSIX.1-2008 defines a standard operating system interface andenvironment, including a command interpreter (or “shell”), and commonutility programs to support applications portability at the source codelevel. It is intended to be used by both application developers andsystem implementers. See: pubs.opengroup.org/onlinepubs/9699919799.

The core vocabulary follows the POSIX. 1-2008 System API though not allapplication programming interfaces are currently provided. Parametersare Things, and where appropriate conversions between character stringsand real integers are provided by the corresponding verb action. Theembodiment of a Thing includes a non-mutable component for systemspecific data so that pointers to data structures can be provided whennecessary. By way of example, the POSIX standard that defines theunlink( ) function is defined as “int unlink(const char*path)” which isembodied as a verb action named “unlink” that acts upon the Thingidentified by the listing request:path. In the embodiment, the functionsare implemented as verb things (i.e., thing:verbs) and configured in theverb namespace, though a suitable namespace such as posix may be usedinstead, and, the context appropriately set for resolving references.

Algorithmic procedures specific to the application domain can beconfigured. A commonly used verb action, such as http:get for example,can be configured to use the GET method of the HTTP protocol to retrievea resource specified by a URI.

Executables can be configured as verb actions using interprocesscommunications, or standard file descriptors. For example, the/bin/date(1) command is well known in the Unix and Linux communities,and can be configured though the output may need to be parsed into asuitable format for the implementation to parse. The listing bin:datefor example, can have a performable action that is to exec(2) the/bin/date executable in a separate address space, and pipe the outputback as the value of the response. The URRbin:date//response:as=“data:date” is interpreted as a request for thebin:date verb action to be performed, and the response (read from thestandard output of the command) to be configured as the value of theThing given by the listing data:date.

Using a well-defined set of verb actions, a task sequence may betranslated to source code which can be compiled and performed as anexecutable to eliminate the steps of evaluating statements and bindingThings.

thing:machine

A Thing that describes an embodiment of a Thing Machine is athing:machine. Referring to FIG. 66 , P(TM) parses the content expressedin the Thing Language that describes a desired configuration for P(TM).P(TM) interacts with P(TM(thing)) to construct a thing:graphrepresentative of the P(TM), and said thing:graph is a thing:machineThing.

One skilled in the art of Public Key Infrastructures can embody anauthenticating action to ensure the authenticity of the content, such asby the use of X509 certificates, digital signatures, and the use ofOpenSSL identity, authentication, and authorization algorithmic actions.

Referring to FIG. 66 , a thing:graph describing a thing:machine iscomprised of a set of Things denoting the vocabularies, including:

-   -   a) a boot vocabulary;    -   b) a core vocabulary; and,    -   c) an application runtime vocabulary;        and optional Things from the set including.    -   d) a hardware Thing; and,    -   e) an operating system Thing.

Note that a hardware Thing can include a processor Thing describing aprocessor, and, one or more component Things. Hardware Things caninclude a vocabulary Thing

The set of Things describing a vocabulary can be comprised of:

-   -   a) the uniform resource request for requesting the verb        vocabulary performable actions to be loaded;    -   b) the content describing the thing:graph of the thing:verbs;    -   c) the listing for the vocabulary;    -   d) a prerequisite things;    -   e) a discipline thing;    -   f) a thing identifying the author;    -   g) a thing identifying the distributor which may be discrete        from the owner;    -   h) a thing identifying the owner which may be discrete from the        author;    -   i) a thing used in authenticating the content;    -   j) a thing used in authorizing the use of the content; and,    -   k) a property from https://www.schema.org/SoftwareApplication

Note that the application vocabulary URR uses stdfile:parse whichperforms the action of reading and parsing the file as thing:statementsto evaluate. In the embodiment, the statements include a set of tasks tobe configured, a runtime task, and a set of services to offer. In theembodiment, the tasks and the services including action blocks and thetask is performed by performing the task's action block. Similarly, theservice is provided by performing the service's action block. Oneskilled in the art can configure a multiplicity of tasks and services.

The following are examples of content expressed in the Thing language,wherein said content describes a TM(i).

TM:RaspberryPi3

The following is an example of content expressed in the Thing language,wherein said content describes a TM(i).

TM:raspberryPi3=( datasheet=”https://cdn.sparkfun.com/datasheets/Dev/RaspberryPi/ 2020826.pdf”  SOC=”Broadcom BCM2837”  CPU=”4x ARM Cortex-A43, 1.2 GHz” RAM=”1GB LPDDR2 (900 MHz)”  Ports=”HDMI” )

TM(raspberryPi3) is a computational machine configured to perform P(TM)comprising the actions: performing self-configuredthing:machine.boot.vocabulary performable actions to configurething:machine.core.vocabulary to interact withthing:machine.hardware.component.parts, and configurething:machine.application.vocabulary; and, perform the applicationruntime.

TM(AMS.TMD26723)

The following is an example of content expressed in the Thing language,wherein said content describes a TM(i). The TMD26723 is a Digitalproximity detector, LED driver and IR LED in an optical module 1.8v I2Cinterface provided by the AMS Corporation (see www.ams.com). The productdatasheet is available atams.com/eng/content/download/364923/1210537/207915

TM:AMS.TMD26273=(  description=”Digital proximity detector, LED driverand IR LED in an optical module”  manufacturer=”AMS” website=”http://www.ams.com”datasheet=”http://ams.com/eng/content/download/364923/1210537/file/TMD2672_Datasheet_EN_v1.pdf”  vocabulary=(   definition=”http://www.thinglanguage/ams/tmd26273/”  listing=”TM:AMS.tmd26273”  urr=”stdlib:///usr/local/iotmachine/tm/libtmd2672.so?entry=’init’”  ))

TM(AMS.TMD26723) is a computation machine configured to interact withthe TM2671 using i2c communications configured as specified by thedatasheet, and, providing P(TM(AMS.TMD26723)) actions as listed in table7, below.

TABLE 7 P(TM(i)) Provides action of disable.interrupts disablingproximity interrupts; disable.proximity disabling the proximityfunction; disable.wait disabling the wait timer; enable.interruptsenabling proximity interrupts; enable.proximity enabling the proximityfunction; enable.wait enabling the wait timer; get.proximity getting thecurrent measured proximity detected; set.command.register Setting thecommand register; set.enable.register setting the Enable Register;set.pdiode setting the TMD26723 to use channel 0 diode, channel 1 diode,or, both channel 0 and channel 1 diodes; set.pdrive setting the LEDstrength; set.persistence controlling filtering interrupt capabilitiesof TMD26723. Interrupts are generated after each ADC integration cycle,or, if the ADC integra- tion has produced a result that is outside ofthe values specified by the threshold register for some specified amountof time; and, set.pgain setting the proximity gain value; set.power.offdisabling the oscillator; set.power.on enabling the oscillator;set.proximity.pulse setting the number of proximity pulses that will betransmitted; set.proximity.register setting the proximity timingregister to control the integration time of the proximity ADC in 2.72 msincrements; set.proximity.threshold setting the high and low triggerpoints for the comparison action for interrupt generation; (Note: If thevalue generated by the proximity channel crosses below the lowerthreshold specified, or, above the higher threshold specified, aninterruptis signaled to P(TM(AMS:TMD26723.receive.interrupt)) which theninteracts with P(TM(thing)) to set a specified Thing to reflect theinterrupt); set.timing.register setting the ALS Timing Register; and,set.wait.time setting the wait time register. If WLONG is set, then theWLONG bit is asserted and the wait times are 12x longer;

Note that in a preferred embodiment, P(TM(i)) will algorithmicallyinteract with P(TM(thing)) to access and interact with Things theP(TM(i)) action can act upon. P(TM(i)) interacts with P(TM(thing)) toset the status to FAILED for any value that is not within range ofvalues permitted by the P(TM(i)) action, and, to set the reason toINVALID VALUE. In a preferred embodiment, the reference names for theactions are configured in the TMD26723 namespace, though a secondembodiment may use a different namespace.

Additional actions can be included by the embodiment including actionsto open a communication channel to the TMD26723 using the i2c interface,thus enabling the actions to act upon a Thing representative of thechannel. This is useful when a multiplicity of TMD26723 sensors is usedin an embodiment.

TM(piborg.ultraborg)

Ultraborg is a Precision servo control with ultrasonic module support,interface board with i2c communication. The board provides 4 HC-SR04Ultrasonic distance sensor connectors, and, up to 4 servo motorconnectors. The HC-SR04 has a field of view viewing angle of 30 degrees.

The following is an example of content expressed in the Thing language,wherein said content describes a TM(i).

TM:piborg.ultraborg=(  description=”Precision servo control withultrasonic module support, interface board with i2c communication” manufacturer=”piBorg”  website=”http://www.piborg.com” datasheet=”https://www.piborg.org/downloads/ultraborg/UltraBorg.PDF” vocabulary=(   definition=”http://www.thinglanguage/piborg/UltraBorg/”  listing=”TM:piborg.ultraborg”  urr=”stdlib:///usr/local/iotmachine/tm/libtmd2672.so?entry=’init’”  ))

TM(piborg.ultraborg) is a computational machine configured to interactwith the Ultraborg using i2c communication configured as specified bythe datasheet, and, providing P(TM(piborg.ultraborg)) action as shown bytable 8.

TABLE 8 P(TM(i)) Provides the action of: Initialize initializing i2ccommunication to an ultraborg board; get.proximity getting the filtereddistance for specified ultrasonic module in millimeters;get.raw.distance getting the raw distance (the unfiltered distance) forthe specified ultrasonic module; get.servo.position getting the driveposition for the specified servo; set.servo.position setting the driveposition for the specified servo; get.servo.minimum getting the minimumPWM level for the specified servo; get.servo.maximum getting the maximumPWM level for the specified servo; get.servo.startup getting the startupPWM level for the specified servo; calidate.servo.position setting theraw PWM level for the specified servo; get.raw.servo.position gettingthe raw PWM level for the specified servo; set.servo.minimum setting theminimum PWM level for the specified servo; set.servo.maximum setting themaximum PWM level for the specified servo; and, set.servo.startupsetting the startup PWM level for the specified servo

Note that in a preferred embodiment, P(TM(i)) will algorithmicallyinteract with P(TM(thing)) to access and interact with Things theP(TM(i)) action can act upon. P(TM(i)) interacts with P(TM(thing)) toset the status to FAILED for any value that is not within range ofvalues permitted by the P(TM(i)) action, and, to set the reason toINVALID VALUE.

In a preferred embodiment, the reference names for the actions areconfigured in the specified namespace, though a second embodiment mayuse a different listing.

In one embodiment, a HC-SR04 ultrasonic sensor is mounted on a surfacethat is rotatable by the servo motor motion. In this manner, the servomotor can rotate the surface, such as in 30 degrees increments, toenable the ultrasonic sensor to incrementally cover a wider area.

In a second embodiment, a HC-SR04 ultrasonic sensor is mounted on afixed position, such as facing forward, to measure distance up to 4meters with a fixed 30 degree field of view.

TM(Ublox.neo-6m-gps)Neo-6M-GPS is a ublox 6 GPS module ROM, crystal using standard GPIOinterfaces.

The following is an example of content expressed in the Thing language,wherein said content describes a TM(i).

TM:Ublox.neo-6m-gps=(  description=”Precision servo control withultrasonic module support, interface board with i2c communication” manufacturer=”Ublox”  website=”http://www.ublox.com”  datasheet=” httpshttps://www.u-blox.com/sites/default/files/products/documents/NEO-6_DataSheet_%28GPS.G6-HW-09005%29.pdf?utm_source-en%2Fimages%2Fdownloads%2FProduct_Docs%2FNEO-6_DataSheet_%28GPS.G6-HW-09005%29.pdf”  vocabulary=(  definition=”http://www.thinglanguage/u-blox/neo-6m-gps/”  listing=”TM:u-blox.neo-6m-gps”  urr=”stdlib:load///usr/local/iotmachine/tm/libneo6mgps.so?entry=’init’” ) )

TM(Ublox.neo-6m) is a computational machine configured to interact withthe u-blox Neo 6M GPS using general purposes i/o configured as specifiedby the datasheet, and, providing P(TM(Ublox.neo-6m)) actions as shown bytable 9.

TABLE 9 P(TM(i)) Provides the action of: Ublox.neo-6m.initializeinitializing communication to ublox neo-6m gps; Ublox.neo-6m.openopening a session; Ublox.neo-6m.close closing a session;Ublox.neo-6m.send sending a command; Ublox.neo-6m.receive receiving aresponse; and, Ublox.neo-6m.wait waiting for a time period, which may bespecified in place of a default time, for data to be available to read;Ublox.neo-6m.get.location Setting a thing:graph representative of thelongitude, latitude, altitude, and time.

Note that in a preferred embodiment, P(TM(i)) will algorithmicallyinteract with P(TM(thing)) to access and interact with Things theP(TM(i)) action can act upon. P(TM(i)) interacts with P(TM(thing)) toset the status to FAILED for any value that is not within range ofvalues permitted by the P(TM(i)) action, and, to set the reason toINVALID VALUE. In a preferred embodiment, the reference names for theactions are configured in the specified namespace, though a secondembodiment may use a different listing.

TM(HC-SR501)

HC-SR501 Pyroelectric Infrared PIR Motion Sensor Detector Module. Thefollowing is an example of content expressed in the Thing language,wherein said content describes a TM(i).

  TM:HC-SR501=(  description=”PIR Motion Sensor”  vocabulary=(  definition=”http://www.thinglanguage/sensor/hc-sr501/”  listing=”TM:HC-SR501”  urr=”stdlib:load///usr/local/iotmachine/tm/libpir.so?entry=’init’”  ))

TM(HC-SR501) is a computational machine configured to interact with thePIR using General Purpose I/O interface as specified by the datasheet,and, providing P(TM(HC-SR501)) action illustrated by table 10.

TABLE 10 P(TM(i)) Provides the action of: Init initializing the HC-SR501communication; and, detect.motion detecting if there was motion.

Note that in a preferred embodiment, P(TM(i)) will algorithmicallyinteract with P(TM(thing)) to access and interact with Things theP(TM(i)) action can act upon. P(TM(i)) interacts with P(TM(thing)) toset the status to FAILED for any value that is not within range ofvalues permitted by the P(TM(i)) action, and, to set the reason toINVALID VALUE. In a preferred embodiment, the reference names for theactions are configured in the specified namespace, though a secondembodiment may use a different listing.

Cirrus Logic Audio Card

The Cirrus Logic Audio Card, produced by Element14 in collaboration withCirrus Logic, offers Raspberry Pi® users similar flexibility to a PCsound-card to capture audio alongside their camera, and experiment withstereo digital capture and playback.

The following is an example of content expressed in the Thing language,wherein said content describes a TM(i).

TM:Element14.CLAC=(  description=”PIR Motion Sensor”  vocabulary=(  definition=”http://www.thinglanguage/element14/CLAC/”  listing=”TM:Element14.CLAC”  urr=”stdlib:load///usr/local/iotmachine/tm/libe14clac.so?entry=’init’” ) )

TM(Element14.CLAC) is a computational machine configured to interactwith the Cirrus Logic Audio Card interface as specified by thedatasheet; a stereo microphone connected to the stereo line input; twoexternal powered stereo speakers are connected to the stereo lineoutput; and, providing P(TM(Element14:CLAC)) actions as illustrated bytable 11.

TABLE 11 P(TM(i)) Provides the action of: initialize initializingcommunication with the CLAC; wake.up detecting if there was notion;start.recording starting a recording session; stop.recording stopping arecording session; sleep transitioning to sleep state listening for awake up command; play.audio.to.headphone playing an audio from aspecified Thing to the headphones; play.audio.to.lineout playing anaudio from a specified Thing to the line out; play.audio.to loudspeakersplaying an audio from a specified Thing to loudspeakers record.from.micrecording from microphone as the value of a specified Thing; record.fromSPDIF.input Recording from SPDIF input as a specified Thing; resetresetting the sound card to defaults.

Note that in a preferred embodiment, P(TM(i)) will algorithmicallyinteract with P(TM(thing)) to access and interact with Things theP(TM(i)) action can act upon. P(TM(i)) interacts with P(TM(thing)) toset the status to FAILED for any value that is not within range ofvalues permitted by the P(TM(i)) action, and, to set the reason toINVALID VALUE. In a preferred embodiment, the reference names for theactions are configured in the specified namespace, though a secondembodiment may use a different listing.

An exemplary embodiment of the Cirrus Logic Audio CardTM(Element14.CLAC) is illustrated by the following:https://www.element14.com/community/serylet/JiveSerylet/downloadBody/65689-102-2-291406/Wolfson%20Audio %20Card %20Schematic %20Diagram.pdf

TM(TI.TMP007)

The TMP007 is an integrated digital thermopile temperature sensor in awafer chip-scale package (WCSP) that detects the temperature of a remoteobject by its infrared (IR) emission. Seeti.com/lit/ds/symlink/tmp007.pdf

The following is an example of content expressed in the Thing language,wherein said content describes a TM(i).

TM:TI.TMP007]=(  manufacturer=”Texas Instruments”  website=”www.ti.com” listing=”Texas Instruments:” datasheet=”http://www.ti.com/lit/ds/symlink/tmp007.pdf  vocabulary=(  definition=”http://www.thinglanguage/ti/tmp007/”  listing=”TM:TI.TMP007”  urr=”stdlib:load///usr/local/iotmachine/tm/libtitmp007.so?entry=’init’” ) )

TM(TI.TMP007) is a computational machine configured to interact with theTI TMP007 as specified by the TMP007 datasheet; and, providingP(TM(TI.TMP007)) actions as illustrated by table 12.

TABLE 12 P(TM(i)) Provides the action of: Initialize initializingcommunication with the TI TMP007; Calibrate calibrating the TMP007;validate.calibration validating the calibration; alert.on.high AlertingP(TM) if the temperature exceeds a specified high temperature;alert.on.low Alerting P(TM) if the temperature is below a specified lowtemperature; validate.alert Validating the alert condition; alert.clearClearing the alert condition; set.mode Setting the mode for TMP007operation to be INT, or COMP; and get.temperature Setting the value of aThing to the recorded temperature.

Examples of P(TM(i))s

As previously stated, the Thing machine is comprised of a multiplicityof TM(i), wherein each TM(i) is a computational machine with procedureP(TM(i)). Examples of different P(TM(i))s, include, but are not limitedto, the following.

The P(TM(format)) action interacts with P(TM(thing)) to format theresponse namespace Thing as the outbound content response Thing theP(TM(output)) action outputs. Note that algorithmic steps ofP(TM(format)) and P(TM(output)) can be combined as a single proceduregiven by an appropriate P(TM(i)), such as P(TM(format.output)).

The P(TM(runtime)) action interacts with P(TM(thing)) to perform aconfigured task thing:graph representative of a sequence of statements,each statement is evaluated by P(TM(eval)) with the correspondingperformable thing:graph to be performed by P(TM(perform)).

P(TM(runtime)) provides the action of algorithmically:

-   -   1. Interacting with P(TM(thing)) to set the value of the Thing        given by the listing status to the value “satisfied”;    -   2. Iteratively performing the following sequence while the value        of said Thing is equal to “satisfied”:        -   a. Interacting with P(TM(parse)) to read content from an            input device, parse said content, and, interact with            P(TM(request)) to generate a corresponding thing:statement            graph;        -   b. Interacting with P(TM(eval)) to evaluate said graph in            the context of Active Things to generate a performable            thing:statement graph; and,        -   c. Interacting with P(TM(perform)) to perform a said            performable thing:statement graph.

The P(TM(runtime)) can be configured as an Active Thing in the set ofboot Active Thing. The P(TM(bootstrap)) action can initialize acommunication channel and set a Thing representative of thatcommunication channel. The P(TM(parse)) action can interact withP(TM(thing)) to access and interact with said Thing as the communicationchannel from which to read content.

The P(TM(runtime)) can be configured as an Active Thing in the set ofbootstrap Active Thing. The P(TM(bootstrap)) action can initialize acommunication channel and set a Thing representative of thatcommunication channel, and, then request the performance of theP(TM(runtime)). The P(TM(parse)) action can interact with P(TM(thing))to access and interact with said Thing as the communication channel fromwhich to read content.

For unknown Things, the P(TM) can interact with P(TM(bind)) whichprovides the action of interacting with P(TM(thing)) to bind an unboundThing as a member of a classification of Things that the P(TM) knows.

P(TM(classifier)) algorithmically classifies the types of statements itis being asked to evaluate, as a classification of interest, andincrements a count for that classification of interest. At apredetermined threshold, the P(TM) adds that classification as a topic,to a list of Things P(TM) should learn about. A P(TM) canalgorithmically determine an appropriate time to learn about a topic.Using a communication device, the P(TM) can request content related tothe topic. This enables the P(TM) to determine the types of topics itwould like to learn, and, the rate at which it would like to learn. Forexample, a Thing Machine that is running at 75% memory capacity, 65%processing capacity, and/or 60% networking capacity may defer spendingadditional resources on learning until a later time. In many cases, aThing Machine would typically stick to those areas of interest relatedto the environment it is performing in. However, by adding a randomselection to the list of topics to learn, the Thing Machine can expandits capabilities to be more generalized. For example, a Thing Machinethat is a vending machine that vends products could learn the actionsrequired to offer car rentals. Whilst that may seem ridiculous on thesurface, think of a vending machine in a busy airport with multiple carrental agencies readily available. Such a machine could learn to use webservices to find which car rental company has a suitable selection forthe consumer, book the rental, bill the consumer and email them areceipt. The P(TM(classifier)) can provide an action to classify athing:statement, and P(TM(eval)) uses said classification to identify aset of active Things available to P(TM(eval)) in selecting an activeThing to satisfy the thing:statement. Other forms of artificialintelligence (AI) can be integrated. For example, symbolic AISub-Symbolic AI, and Statistical AL algorithmic procedures may be used.

A P(TM(eval)) can generate and cause performance of a first performablething:statement and use the response thereof in performance of a secondperformable thing:statement. In an embodiment, the first performablething:statement can perform P(TM(classifier)) to classify the type ofthing:statement being evaluated, such as the topic. In response thereto,the P(TM(eval)) can use the classification to generate the secondperformable thing:statement, or set the context of accessible ActiveThings of the generated performable thing:statement.

Referring to FIG. 33 , P(TM(parse)) interacts with input device (notillustrated) and P(TM(thing)) to provide the action of generating arequest thing:graph; P(TM(eval)) interacts with P(TM(thing)) to providethe action of evaluating the request thing:graph in the context ofaccessible performable actions to generate a performable thing:graph;P(TM(perform)) interacts with P(TM(thing)) to provide the action ofperforming the performable thing:graph wherein said graph is to performa P(TM(configure)) to change the graph of performable actions P(TM) canperform. In an embodiment, input device is a file system device andcontent is a configuration document syntactically adhering to a languagegrammar, describing at least one Active Thing to configure. In apreferred embodiment, the parser action and the format action adhere tothe Thing Language grammar. In this configuration, the vocabulary ofActive Things is dynamically configured from a set of configurationdocuments.

Referring to FIG. 34 , P(TM(env)) interacts with input device (notillustrated) and P(TM(thing)) to provide the action of generating arequest thing:graph; P(TM(eval)) interacts with P(TM(thing)) to providethe action of evaluating request thing:graph in the context ofperformable actions to generate a performable thing:graph;P(TM(perform)) interacts with P(TM(thing)) to provide the action ofperforming the performable thing:graph wherein said graph is to performa P(TM(configure)) to change the graph of performable actions P(TM) canperform.

In a preferred embodiment, the input device is an electromagneticwaveform device. In this configuration, a portion of thething:graph(monad) is algorithmically modified based on the input fromthe environment, and thus, the P(TM) adapts to the needs of theenvironment in which it is performing.

In one environment a P(TM) action plays an audio message asking the user“How can I be of service”, and, a second action records the userresponse. A voice to text action converts the audio to text, which isparsed as a thing:graph. A classifier action algorithmically classifiesthe topic of conversation. The P(TM) communicates a request for tasksrelated to the topic to a second Thing Machine. In response to receivingthe information, the first P(TM) algorithmically configures the task,and, performs the task.

In a second embodiment, a Thing Machine includes a receiver opticalsubsystem assembly and is used to interrogate a user provided OpticalIdentifier (OD, and, in response thereto, configures a portion of thething:graph(monad) to include performable thing:graphs specific to thatuser. When a user performs an affirmative action, such as by removingthe OI from the optical reader, the P(TM) forgets that portion of thething:gram(monad) specific to the user.

In a third embodiment, a Thing Machine includes a biometric device, suchas EyeLock, to identify a user, and, performs an action to configure aportion of the thing:graph(monad) to include performable thing:graphsspecific to that user. When a user performs an affirmative action, suchas by leaving the area of the biometric device, the P(TM) forgets thatportion of the thing:gram(monad) specific to the user.

P(TM(thing)) provides the action of algorithmically initializing andorganizing representations of Things and the relationships between them,in non-volatile memory, as a thing:graph. In an embodiment supportingclasses, P(TM(thing)) is comprised of discipline P(TM(thing:class))procedures such as: P(TM(thing:class.set)) to set a Thing satisfying therequirements of what it means for the instance of the Thing to be amember of that class; P(TM(thing:class.get)) to get a reference to aThing of that class; and, P(TM(thing:class.unset)) to unset an instanceof a Thing of the specified class. Modifier actions enable P(TM(thing))procedures to be modified such as “before” or “after” thus enabling“before set, perform this action” or “after set, perform this action.”

Each instance of a Thing is comprised of a set of non-mutable componentsused by P(TM(thing)) In the preferred embodiment, said set includes: athing:name, a thing:value, and, a thing:relationship-set. An embodimentcan extend the set to incorporate additional components as specifiedthrough content the P(TM(thing)) can interact with, such as content in aconfiguration file.

Referring to FIG. 35 , during initialization, P(TM(thing)) allocates andinitializes a Thing with the name equal to monad, as the root of theThing Machine's thing:graph, and allocates and initializes a Thing withthe name context, and sets the relationship so that the assertion:“There is a Thing where name is equal to monad, such that, there is aThing where name is equal to context” is true.

Referring to FIG. 36 , the context quantifies the set of Things that arein scope for resolving a listing comprised of one or more free variablesand expressions of relationships between them. By way of example,http://www.iotnamespace.com/thing and request:statement andstatement.thing[1] are examples of listings.

Referring to FIG. 37 , in the preferred embodiment, the context Thing isa thing:stack, through which the P(TM(thing)) can algorithmically push aThing onto the stack, or pop a Thing off the stack, thus changing thecontext. The P(TM(thing)) algorithmically uses the Thing at the top ofthe stack as the current context, in quantifying the set of Things thatare in scope for resolving a listing.

Referring again to FIG. 36 , in the preferred embodiment the currentcontext Thing has a relationship set comprising relationships to one ormore Things referred to as namespace Things. The name of the Thing isthe name of the namespace. The P(TM(thing)) algorithmically uses anamespace Thing as a Thing that represents a named Thing graph ofrelated Things, even if related solely by being qualified in the samenamespace. A URI scheme name can be the name of a Thing that is anamespace. The URI scheme-specific part is a listing that identifies aThing qualified in that namespace.

Referring to FIG. 38 , a Thing that has a representation of a referenceto a performable action is classified as an Active Thing. An ActiveThing is a thing verb and has a corresponding Active Thing GraphG(P(TM(i))). The Subject node name is replaced with a correspondingActive Thing name, and, the G.request acts-upon Blank Node is replacedby a graph of the Things that the P(TM(i)) can act upon. EachG(P(TM(i))) includes a:

-   -   a) G.identifer(P(TM(i)) Thing whose name is an identifier        identifying the P(TM(i)), and is the root node (the subject        Thing) in a directed graph;    -   b) G.urr(P(TM(i))) URI Thing whose value denotes a request for        the P(TM(i)) to act upon a G.request; and,    -   c) G.request(P(TM(i))) Thing graph denoting the set of Things        the P(TM(i)) can act upon.

Referring to FIG. 39 , in an embodiment, the G(P(TM(i))) can includeadditional Thing information, such as a description of the Things thatcomprise a response from performing P(TM(i)).

An embodiment can include a multiplicity of G.request graphs for a givenG(P(TM(i))) to indicate various permutations of Things the P(TM(i)) canact upon. Such an embodiment can further include a multiplicity ofG.response graphs indicating the Things that constitute thecorresponding response graphs.

FIG. 40 is the G(P(TM(thing.set))) graph corresponding to the P(TM(Thingset)) procedure for setting a Thing in non-transitory memory. The valueof the request:uri Thing is the listing of the Thing to be set, and, itsvalue will be set to the value of the request:value Thing, if specified.If a request:using Thing is specified, then its value is a listingrepresentative of a Thing to use in setting the Thing identified by thevalue of the request:uri Thing.

FIG. 41 is the G(P(TM(thing.get))) graph corresponding to theP(TM(Thing.get) procedure for getting a representation of the Thinggiven by the listing request:uri, non-transitory memory. The modifiersname, value, or relationship-set, or relationship can be used to denotespecific information requested about the Thing. The information is savedas the value of the Thing given by the listing denoted by the value ofrequest:as Thing.

FIG. 42 is the G(P(TM(thing.unset))) graph corresponding to theP(TM(Thing.unset) procedure for unsetting a representation of a Thingfrom non-transitory memory. The Thing to unset is given by the value ofthe request:uri Thing.

One skilled in the art can replace P(TM(thing)) with an alternativealgorithmic procedure to administer Things and their relationships tofurther enable features such as concurrency, persistence, caching,synchronization, locking (such as read/write locks), ownership,permissions (such as read/write/execute by owner, group, or all).

P(TM(eval))

P(TM(eval)), as described by FIG. 45 , algorithmically interacts withP(TM(thing)) to provide the action of:

-   -   a) selecting a thing:statement to evaluate;    -   b) selecting a G(P(TM(i))) as the performable Active Thing from        the set of accessible Active Things;    -   c) initializing a new context Thing as a performable context        Thing;    -   d) performing the G.urr of the performable G(P(TM(i))) in the        context of the performable context Thing;    -   e) resetting the performable context Thing to a current context        Thing; and,    -   f) unsetting the new context Thing.

In an embodiment, step a and step b consist of selecting an Active Thingthat satisfies the assertion: (There is a thing:statement where listingis equal to request:statement, such that, there is a Thing where Name isequal to.name) and (There is a Thing where listing is equal toverb:vocabulary, such that, there is a thing:verb where Name is equalto.name and Thing is an Active Thing).

In a preferred embodiment, step b can include the step of selecting adefault Active Thing when the assertion is not otherwise satisfied.

For an Active Thing with instances, P(TM(eval)) can include the step of:selecting the instance of Active Thing where thing:statement is asubgraph of the instance's G.Request graph.

In an embodiment, the P(TM(eval)) can interact with P(TM(bind)) toinclude the step of binding the Things qualified by the thing:statementThing, using the corresponding G.request graph of the performable ActiveThing, as Things in the performable context Thing that the Active Thingaction can act upon.

In an embodiment, P(TM(eval)) algorithmically classifies the type ofstatement as an imperative statement; a declarative statement; aninterrogative statement; or, an exclamatory statement, and performs anactive Thing to evaluate said class of statement. This enables aP(TM(eval.declarative)) procedure to algorithmically evaluate adeclarative statement; a P(TM(eval.imperative)) procedure toalgorithmically evaluate an imperative statement; aP(TM(eval.interrogative)) procedure to algorithmically evaluate aninterrogative statement; and, a P(TM(eval.exclamatory)) procedure toalgorithmically evaluate an exclamatory statement.

The action of P(TM(eval)) can algorithmically select a default ActiveThing for the performable thing:statement, and, can algorithmicallyevaluate the thing:statement to determine a more appropriate ActiveThing to use. The default action can interact with P(TM(thing)) toincrement a counter Thing associated with the classification of thething:statement for which the default action was performed, to representthe number of times the Thing Machine was asked to perform thatclassification of a thing:statement. Using performable communicationactions, a P(TM(i)) can communicate with a second machine to obtaincontent related to said classification. P(TM(parse)) action can parse asthing:statements to evaluate and perform. In this manner, the ThingMachine can adapt to the needs of the environment in which it isperforming. (The goal here is that you ask the machine to do something.The machine selects a default action, then evaluates whatever you askedto see if there is a better action to perform. If not, it performs thedefault. The default action classifies the topic, and increments acounter for the number of times it was asked to do something related tothat topic. This way, when the counter hits a threshold, the machine canask somebody to teach it about that topic, or buy books to read relatedto that topic.

An embodiment can merge graphs between contexts so that if a response.asThing is specified, P(TM(eval)) can bind the subgraph of the response:namespace Thing in the new context, as the subgraph of the response.asThing in the current context before unsetting the new context Thing.

In an embodiment P(TM(eval)) can include the step of: pushing the newcontext onto the context stack as the current context before the step ofperforming the G.urr. In a second embodiment, one skilled in thecomputer art of parallel processing would use a Thing representative ofa graph of thread specific data of a Process Control Block Thing, andsaid data includes a reference to the current context for resolution ofa listing by P(TM(thing)).

Referring to FIG. 43 , the G.request denotes that the action can actupon a request:statement that is a thing:statement. Thus, the subgraphof the request:statement Thing, would need to satisfy the requirementfor being a member of the class of Things that are a thing:statement.

Referring to FIG. 44 , the G.request subgraph indicates the action canact upon a request:using Thing that is a thing:listing. This graphapplies if it is true that there is a request namespace Thing, suchthat, there is not a (thing:sttina) Thing where name is equal tostatement, and there is a Thing where name is equal to using. ThisG.request subgraph provides an alternative method for selecting theevaluate Active Thing.

The algorithmic use of Artificial Intelligence is expressly contemplatedfor. P(TM(classifier)) provides actions to classify a thing:statement,and, P(TM(eval)) uses said classification to identify a set of ActiveThings available to P(TM(eval)) in selecting an Active Thing to satisfythe thing:statement. Other forms of Artificial Intelligence can beintegrated. For example, Symbolic AI, Sub-Symbolic AI, and StatisticalAI algorithmic procedures may be used.

Google Research released TensorFlow, an open source machine learninglibrary, primarily used for academic and research activities. Oneskilled in the Computer Science art of Machine Learning can use theTensorFlow API to develop a P(TM(classifier)) for deep learning. TheTensorFlow API can be modified to directly interact with P(TM(thing)) asa set of Active Things representative of the Tensorflow procedures to beconfigured. Training data can be provided through the set of ActiveThings.

P(TM(eval)) provides the action of: a) interacting with P(TM(thing)) togenerate a request classifier thing:statement requesting performance ofP(TM(classifier)) to classify the current request thing:statement; b)interacting with P(TM(bind)) to bind the classifier thing:statement as aperformable thing:statement; c) interacting with P(TM(perform)) toperform the performable thing:statement; and, d) interacting withP(TM(thing)) to interact with the result thereof.

The result thereof identifies a classification (a class) related to thecurrent request thing:statement. For a class of Things that are known toP(TM), P(TM(eval)) interacts with P(TM(thing)) to set the context toinclude the vocabulary related to the class and evaluates the currentrequest thing:statement in that context.

P(TM(eval)) increments a counter representative of the topic, to denotethe number of times that topic applied to a current requestthing:statement, which enables the classifier to classify thething:statements according to the most frequently used topic. When P(TM)does not have a vocabulary for a given topic, P(TM(eval)) can generate athing:statement to evaluate that represents a default action.

A first P(TM) can communicate with a second P(TM) such as through WiFicommunications, to request content related to the class ofthing:statements the P(TM) commonly is being asked to evaluate andperform. Said content may be representative of Things such as ActiveThings, and Things that the action of the Active Thing can act upon,such as tasks.

An embodiment can replace P(TM(eval)) with an evaluation action toalgorithmically perform an evaluation appropriate for the embodiment,such as one that supports a given language; implements a particularmachine learning algorithm; embodies a multiplicity of machine learningalgorithms; provides performance improvements, or interacts with asecond machine to evaluate the thing:statement; interacts with a thirdmachine to perform the thing:statement. One skilled in the art wouldunderstand a multiplicity of algorithmic modifications are possiblewithin the scope of the invention.

Modifiers can be used as Things in a thing:statement to modify thedefault P(TM(eval)) procedural action. Alternatively, P(TM(eval)) caninteract with a P(TM(classifier)) to algorithmically classify the typeof Thing being evaluated, and said type of Thing can be used as themodifier to select and perform an Active Thing. By way of example,evaluating a statement representative of an imperative statement, suchas “Perform the task named cleanup” is distinct from evaluating astatement representative of a declarative statement, such as: “Declare atask named cleanup comprises step 1: flush the compoint I/O; and step 2:close the compoint I/O.”

By incorporating the types of Things an action can act upon, into thething:graph of the P(TM(i)), and incorporating the types of Things theaction can respond with, appropriate actions can be selected for commonverb names, such as open. By way of example, each of the following hasvery different action though each uses a common verb name: open myemail; open the gate; and, open a bank account. Selecting the correctaction depends in part on what is being opened. By including adescription of the type of Things an action can act upon, theP(TM(eval)) can make an appropriate selection as to the performablething:graph that it should generate.

P(TM(parse))

P(TM(parse)) provides the action of parsing an input representative of arequest, and algorithmically interacting with P(TM(request)) to set aThing to be representative of the parsed input. In the preferredembodiment, P(TM(parse)) is an XML 1.1 parser.

Referring to FIG. 46 , the value of the Thing identified by the listingrequest:stream, is the stream to be parsed. The Thing identified by thevalue of the request:as Thing, which defaults to request:statement, isset as a thing:statement representative of the parsed input request.

Referring to FIG. 47 , the exemplary XML fragment is parsed as theexemplary graph. Note that the element attribute is denoted via the“such that there is an instance” relationship (thing:sttiai), while theelement is denoted via the “such that there is a” relationship(thing:sttia).

Referring to FIG. 48 , the value of the Thing given by the request:inputlisting, is the input to parse. The TM(eval) can select the appropriateG.request(P(TM(parse))) graph based on the request graph, and facilitatethe appropriate bindings.

It is noted that there is a subtle but important distinction betweenParse-1 and Parse-3, specifically, in 1, the action will read from thestream. Alternatively, in 3, the action uses the value of request:inputlisting (where the value is the content to parse).

This is needed because in certain cases, you would obtain content from afile, and in other cases, an action generates the content and stores itas the value of thing.

P(TM(request))

P(TM(request)) provides the action of algorithmically interacting withP(TM(Thing)) to set the Thing identified by the listing given as thevalue of the request:as Thing, using the Thing identified by the listinggiven as the value of the request:using Thing, as a thing:statementThing graph.

A first P(TM(i)) can be used to iteratively construct a thing statementThing, and, then to algorithmically interact with P(TM(request)) to setthe request:statement Thing. FIG. 49 illustrates the G(P(TM(request)))graph. The default value of the request:as Thing, is request:statement.

P(Tm(bind))

P(TM(bind)) algorithmically applies a set of binding rules, in anattempt to bind a Thing as a member of a given class of Things.

By way of example, a Thing whose value matches the pattern “[0-9]{1,}”could be bound as a thing:integer (a Thing with an integer value),whilst a Thing whose value matches the pattern “[0-9A-Fa-f]” could bebound as a thing:hexadecimal (a Thing with a hexadecimal value). Inaddition to basic classes of Things, such as: thing:thing, thing:text,thing:integer, thing:float, and thing:string, additional types can beexpressed using rules of inference, or schemas.

Referring to FIG. 50 , the G.request subgraph indicates the Things thatthe P(TM(bind)) can act upon. The value of the Thing given byrequest:using is a listing identifying a set of binding rules. The valueof the Thing given by request:bind.listing is the listing identifyingthe thing:graph to be bound. The value of the Thing given byrequest:response.as is a listing identifying a thing:graph in which theresponse is to be set. When request:response.as is empty, then the graphof the Thing being bound is updated.

P(TM(bind)) can use state information such as unbound or bound to denoteif a Thing has already been bound. This enables P(TM(bind)) to check thestate and only perform the binding rules on an unbound Thing.P(TM(bind)) can further include a “found” and “not found” state todenote if the Thing has been bound and found, or bound and not found. Ina preferred embodiment, a P(TM(unbind)) interacts with P(TM(thing)) toreset a Thing to the unbound, not found state.

In a first embodiment, one skilled in the art of Computer Science logicuses rules of inference to bind a Thing as a member of a class ofThings. A rule is comprised of an assertion and a class identifier.P(TM(bind)) interacts with P(TM(thing)) to algorithmically apply therule as an assertion about the Thing to be bound, and, if satisfied,P(TM(bind)) interacts with P(TM(thing)) to classify the Thing as amember of the said class identifier.

In a second embodiment, one skilled in the art of Computer Sciencemarkup languages can use a thing:schema markup language to describe aThing class. Industry standard markup schemas are available fromschema.org/docs/schemas. Said schemas are a set of types, eachassociated with a set of properties. Seehttp://schema.org/docs/documents.html for Schema.org schema information,which is incorporated by reference.

Referring to FIG. 51 , the thing:graph is interpreted as an assertiondescribing the membership requirements for a Thing to be bound as amember of the ImageObject class. The interpretation is an assertionexpressing: There is a Thing where name is equal to schema, such that,there is a Thing where name is equal to ImageObject and Thing is athing:schema, such that, (there is a Thing where name is equal toCaption and thing:value is a thing:text), and, (there is a Thing wherename is equal to exifData and thing:Value is a thing:text), and, (thereis a Thing where name is equal to representativeOfPage and thing:valueis a thing:Boolean), and, (there is a Thing where name is equal tothumbnail and thing:thing is a schema:ImageObject).

Referring to FIG. 52 , an unbound thing:graph given by the listinglocal:object is presented.

Referring to FIG. 53 , the thing:graph illustrates a request to bind thelocal:object thing:graph as a schema:ImageObject Thing (as described byhttp://www.schema.org/ImageObject). P(TM(bind)) interacts withP(TM(Thing)) to determine if the components of the local:objectthing:graph satisfy the requirements for being a schema:ImageObject. Thelocal:object Thing state transitions from unbound to bound. Ifsatisfied, the node “bound.found” is added to the local:objectthing:graph, and, the value of the node is set to schema:ImageObject.

One skilled in the art of Computer Science logic can use Rules ofInference to algorithmically make inferences about Things. An inferencerule consists of a Procedure which acts upon a thing:graphrepresentative of premises, and generates a thing:graph representativeof a conclusion. Referring to FIG. 54 , the assertion describes what itmeans for a Thing to be classified as a BroadcastService. The assertionis parsed and represented as a rule of inference for the specifiedclassification. P(TM(bind)) provides the action of algorithmicallyevaluating if a specified thing:graph satisfies the rule of inference,and if satisfied, classifying the thing:graph as a member of thespecified classification. Referring to FIG. 54 again, one skilled in theart of computer science schemas can generate a rule of inference for aset of schemas, such as the set published by schema.org available atschema.org/docs/full.html.

Note that http://www.schema.org/PerformAction relates to the act ofparticipating in performing arts, not to a machine performing aperformable action. Note further that schema.org Actions relate to avocabulary that enables websites to describe an action they enable, and,how a client can invoke these actions. Seeblog.schema.org/2014/04/announcing-schemaorg-actions which isincorporated by reference.

P(Tm(perform))

P(TM(perform)) algorithmically performs a performable thing:statement bylocating the reference to the P(TM(i)) in the thing:statement, and,causing the P(TM(i)) action to be performed. The response from action iseither: satisfied, unsatisfied, or failed. The P(TM(perform)) actionsets the status Thing value to indicate this response.

Referring to FIG. 55 , the G.request subgraph indicates theP(TM(perform)) action acts upon a request:statement.

P(Tm(task))

P(TM(task)) algorithmically interacts with P(TM(thing)) to administer athing:graph as a thing:task comprised of a set of subgraphs including athing:list of thing:statements.

In an embodiment, the actions of P(TM(task)) can be comprised of:

-   -   a) P(TM(task.set)) to interact with P(TM(thing)) to set a        thing:task;    -   b) P(TM(task.get)) to interact with P(TM(thing)) to get a        reference to a thing:task;    -   c) P(TM(task.unset)) to interact with P(TM(thing)) to unset a        thing:task; and,    -   d) P(TM(task.perform)) to interact with P(TM(thing)),        P(TM(eval)), and, P(TM(perform)) to evaluate and perform the        thing:statements of a thing:task.

Referring to FIG. 56 , P(TM(task.set)) interacts with P(TM(thing)) toalgorithmically act-upon a Thing identified by the listingrequest:statement.task, whose value is a listing of a Thing to be set asa thing:task. The action subgraph of the request:statement.task is setas a subgraph of the thing:task Thing. An embodiment may include aG.request subgraph as request:statement.task.G.request and said subgraphis representative of the Things the task is to act upon.

P(TM(task.get)) interacts with P(TM(thing)) to algorithmically get arepresentation of a thing:task, and is primarily used by other P(TM(i))needing access to that graph, such as the P(TM(task.perform)).

P(TM(task.unset)) interacts with P(TM(thing)) to algorithmically unset(remove) a specified task from the thing:thing(monad) graph.

Referring to FIG. 57 , P(TM(task.perform)) interacts with P(TM(thing)),P(TM(eval)), and P(TM(perform)) to algorithmically evaluate and performthe sequence of thing:statement subgraphs given by the action subgraphof the thing:task identified by the value of request:statement.task.

In an embodiment, a thing:task graph can include a thing:statementsubgraph that can be evaluated and performed as a prerequisite toevaluating and performing the thing:task action subgraph. This enablesthe performance of a set of Active Things to obtain contentrepresentative of the action subgraph, to parse said content as thesequence of thing:statements of the action subgraph that is to beevaluated and performed. Other actions can include identification,authentication, and authorization to validate, authorize or rejectperformance of the thing:task. Similarly, prerequisite actions can beused to ensure a prerequisite condition is satisfied prior to evaluationof the thing:task, such as configuring Active Things.

In an embodiment, the thing:task can include an on.status subgraphrepresentative of a thing:statement to evaluate and perform, dependingon the value of the status Thing. After each thing:statement isevaluated and performed, an embodiment can interact with P(TM(thing))action to algorithmically test the status to see if the value issatisfied, unsatisfied, or failed, and, evaluate and perform thecorresponding on.status.satisfied, on.status.unsatisfied, oron.status.failed thing:statement subgraphs.

An embodiment can include an on.status subgraph representative of athing:statement to evaluate and perform, depending on the value of thestatus Thing. After each thing:statement is evaluated and performed, anembodiment can interact with P(TM(thing)) action to algorithmically testthe status to see if the value is satisfied, unsatisfied, or failed,and, evaluate and perform the corresponding on.status.satisfied,on.status.unsatisfied, or on.status.failed thing:statement subgraphs.

P(TM(format))

P(TM(format)) provides the action of interacting with P(TM(thing)) totraverse a thing:graph and generate a formatted representation of saidthing:graph. By way of example, a representation of a thing:graph can beformatted as an XML document, an HTML document, a Thing document, orother such format as required by an embodiment.

Referring to FIG. 58 , the request:statement.listing identifies a Thingwhose value is a listing representative of a thing:graph that theP(TM(format)) is to format. The request:statement.as identifies a Thingwhose value is representative of a thing:graph representative of theresulting format response. The request:statement.using identifies aThing whose value is representative of the desired format.

The default P(TM(format)) to use is Thing-XML. Nodes of the thing:graphbeing traversed are formatted as the root element. Subgraphs that areinstances are formatted as attributes whilst non instance subgraphs areformatted as inner elements.

In an embodiment, a P(TM(format)) can interact with P(TM(thing)) totraverse a thing:graph to generate a stream of text andP(TM(text-to-speech)) to perform a synthesis of the stream of text to anaudible stream containing the synthesized spoken text representation.P(TM(play-audio)) communicates the audible stream to the sound subsystemto produce the audible playback.

P(TM(http:get))

P(TM(http:get)) provides action of algorithmically interacting withP(TM(thing)) to generate a URI; communicating an HTTP GET method requestfor the resource identified by URI; receiving the HTTP response; and,generating a thing:graph representative of the HTTP response including aresponse.headers thing:subgraph, and, a response.entity thing:subgraph.

One skilled in the art of Computer Science Web Services can use a set ofHTTP method Active Things to provide HTTP methods such as: connect,delete, get, head, options, post, put, and trace in the vocabulary. Theset of methods can be configured relative to the http: namespace.Similarly, one skilled in the art can provide a set of methods relatedto the HTTPS protocol and said set can be configured as Active Things ofthe https: namespace.

Referring to FIG. 59 , the URI Thing qualifies a domain Thing, a pathThing, and a request Thing that qualifies a header Thing. TheP(TM(http:get)) interacts with the P(TM(thing)) to algorithmicallyinteract with the URI Thing to generate an HTTP Get Method request(illustrated in FIG. 60 ) and communicates said request to the domainweb service. In response thereto, P(TM(http:get)) receives a response(see FIG. 61 ).

Referring to FIG. 61 , P(TM(http:get)) performs the action of receivingthe response from the HTTP Get Method request; parsing the response andinteracting with P(TM(thing)) to set a thing:graph representative of theresponse, such as that shown in FIG. 62 .

The request.header Thing can be configured with a set of request headerfield components, each expressed as a Thing qualified by request.header.Similarly, in response to receiving and parsing the response header, theresponse.header Thing can be configured with a set of response headerfield components, each expressed as a Thing.

In an embodiment, P(TM(http:get)) performs the action of interactingwith P(TM(thing)) to get a set of Things representative of media typesthat are acceptable in the response, and adds the Accept request headerfield to the request header thing:subgraph accordingly. In a secondembodiment,

P(TM(http:get)) performs the action of interacting with P(TM(thing)) toget a set of encodings that are acceptable in the response, and adds theAccept-Encoding header field to the request header accordingly.

P(TM(parse.html))

P(TM(parse.html)) interacts with P(TM(thing)) to algorithmically providethe action of parsing a thing:graph representative of HTML content, intoa set of thing:graphs.

Referring to FIG. 63 , P(TM(parse.html)) acts upon a request:contentThing whose value is a listing representative of Thing whose value isHTML content to parse. Anchor links embedded in the HTML, that arequalified within the same domain as the HTML content, are classified asinternal links and are added to the thing:graph of the Thing identifiedby the requestlinks.internal Thing value. Similarly external links areadded to the thing:graph of the Thing identified by therequest:links.external Thing value. Untagged text is saved to the valueof the Thing identified by the request:text Thing value. HTML tags areadded to the thing:graph of the Thing identified by therequest:architecture Thing value. Microdata is added to the thing:graphidentified by the request:microdata Thing value.

Referring to FIG. 64 , exemplary microdata in HTML content isillustrated. P(TM(parse.html)) provides the action of interacting withP(TM(thing)) to parse said content, and, representing the microdata as athing:graph, as shown in FIG. 65 .

As illustrated, a first schema can include a second schema, such asOrganization can include an address, as described byhttp://www.schema.org.

TM(openssl)

Potions of the P(TM(openssl)) are covered under the OpenSSL LicenseAgreement included in this disclosure. TM(openssl) is a computationalmachine configured with the OpenSSL open source software and ProcedureP(TM(OpenSSL)). OpenSSL is well known in the state of the art and usedextensively with web services to provide TLS and SSL protocol actions, ageneral purpose cryptographic library, and, support programs for aPublic Key Infrastructure. See www.openssl.org for details.

In learning the P(TM(openssl)) thing:verbs, a P(TM) can perform a set ofactions commonly provided by a Certificate Authority. For example, oneskilled in the art of Computer Science Public Key Infrastructure can usethe P(TM(openssl)) verb actions for: to encrypt content; to decryptcontent; to generate a hash code; to generate a certificate signingrequest; to sign a certificate; to create a self-signed certificate; tovalidate a certificate request; to validate a certificate; to revoke acertificate; to algorithmically examine a component of a certificate; togenerate a digital signature; to validate a digital signature; toprovide a set of services normally associated with a certificateauthority; to authorize the use of a certificate for a purpose; and, toenable the use of SSL/TLS protocols.

For use with P(TM), the OpenSSL source code was modified so that theoriginal C source code functions could interact with P(TM(thing)) toreference Things as parameters. One skilled in the art of ComputerScience could modify similar existing source code libraries and use theconfigure action to configure additional P(TM(i)).

In general, OpenSSL commands are configured as actions the P(TM) canperform where the command name is configured as a thing:verb, and theparameters the command acts upon are configured as Things the thing:verbaction can act upon.

Several of the P(TM(i)) can act upon content representative of data,which may be further classified as a: certificate signing request; acertificate; a password; a private key; a public key; configurationinformation; a certificate to revoke; an extension; random data; or,some other type of Thing an action can act upon. In some cases, contentis parsed by a P(TM(i)) and represented as Things in a Thing graph,whilst in other cases, content is used as the value of a Thing given bya listing. In many cases, a Thing that an action can act upon can bespecified as a Thing.urr which is interpreted as a Uniform ResourceRequest for that Thing. Similarly, a P(TM(i) may algorithmicallygenerate content representative of data, which may be furtherclassified, such as described above.

In some cases, content may be parsed by a P(TM(i)) and represented asThings in a thing:graph, whilst in other cases, content can be used asthe value of a Thing given by a listing. An action may interact with asystem device driver to obtain or store content in a second storagedevice, to communicate content to a second P(TM), or, to communicatecontent to a sensor or device.

In general, for Things that can have value, the Thing may be specifiedas thing:name.urr=URR (wherein URR is a Uniform Resource Request) in athing:statement being evaluated by P(TM(evaluate)) to generate aperformable thing:graph. For clarity, this will be called step 1.

In traversing the thing:statement thing:graph, the P(TM(evaluate)) willsee the thing:name.urr and evaluate the URR to generate a performablething:graph. The performable thing:graph is performed to generate aresponse thing:graph. The P(TM(evaluate)) in step 1 will use theresponse thing:graph in evaluating and binding the thing:statementThings.

Specific examples of P(TM(openssl)) actions are provided in thefollowing pages to provide the reader with sufficient explanation tothen provide the remainder of the openssl commands following the sameformat.

Several of the P(TM(i)) actions can act upon a common set of Things,which are provided below in table 13.

TABLE 13 Help This Thing indicates the response should include adescription of the Things the ca verb action can act upon. response.asThe value of the Thing given by the listing response.as, is a listingrepresentative of a thing:graph in which the response is to set. usingThe value of the Thing given by the listing, is a listing of athing:graph to be used in binding Things to the Things the action canact upon. This enables the P(TM(bind)) to use a thing:graph to augmentthe Things in the request namespace. request.urr The value of the Thinggiven by the listing is a Uniform Resource Request for Things the actionis to act upon. P(TM(evaluate)) evaluates the URR to generate aperformable thing:graph, interacts with P(TM(perform)) to perform theperformable thing:graph, and, uses the response namespace thing:graph toset the request namespace thing:graph for the action. input.urr Thevalue of the Thing given by the listing, is a Uniform Resource Requestto obtain content. P(TM(evaluate)) evaluates the URR to generate aperformable thing:graph, interacts with P(TM(perform)) to perform theperformable thing:graph, and, uses the response namespace thing:graph toset a Thing representative of the content in the request namespacething:graph for the action to act upon. output.urr The value of theThing given by the listing is a Uniform Resource Request (URR) that theresponse is to be used as the request for. The URR could be, forexample, bound to an action to write the content to a filename such asin stdfile:write///usr/local/openssl/cert/cert.pem?listing=“request:”The default response is set as the value of the response:statementThing. configuration.urr The value of the Thing given by the listing isa Uniform Resource Request representative of a request to obtain contentrepresentative of the openssl configuration content. This may bespecified as an input filename to read.P(TM(openssl.ca))

The P(TM(openssl.ca)) provides the action of a minimal CertificateAuthority.

Things the openssl.ca verb action can act upon include those listed intable 14 below.

TABLE 14 verbose This Thing indicates the response should include extradetails about the actions being performed. configuration.urr The valueof the Thing given by the listing is a Uniform Resource Requestrepresentative of a request to obtain content representative of theopenssl configuration content. This may be specified as an inputfilename to read. name The value of the Thing given by the listingspecifies the configuration content section to use (overrides default.cain the ca section). ss.certificate The value of the Thing given by thelisting is a Uniform Resource Request to obtain content representativeof a single self-signed certificate to be signed by the CA. This may bespecified as an input filename to read from. Input.files The input filesThing is a list of Things, each representative of an input file pathname containing a certificate request. output.directory The value of theThings is a pathname to an output directory in which the outputcertificates are to be saved. The certificate will be written to afilename consisting of the serial number in hexadecimal form with a .pemsuffixed appended. certificate.urr The value of the Thing given by thelisting is a Uniform Resource Request (URR) for requesting the CAcertificate. This may be a pathname to a file containing the CAcertificate. key.form The value of the Thing given by the listingspecifies the format (DER or PEM) of the private key file used in thesign.key option. key.urr The value of the Thing given by the listing isa Uniform Resource request (URR) for requesting the password that willbe used to encrypt the private key. password used to encrypt the privatekey. ley The value of the Thing given by the listing is a password usedto encrypt the private key (Note: that key has precedence over key.urr)self.sign The self-sign Thing indicates the issued certificate is to besigned with the key the certificate requests were signed with.Certificates signed with a different key are ignored. If spkac, ss.cert,or gen.crl is given, then self.sign is ignored. A consequence of usingself.sign is that the self-signed certificate appears among the entriesin the certificate database (see the configuration option database), anduses the same serial number counter as all other certificates sign withthe self-signed certificate. passin.urr The value of the Thing given bythe listing is a Uniform Resource Request for requesting the passwordkey. no.text This Thing indicates that the text form a certificateshould not be provided in the response. start.date The value of theThing given by the listing represents the start date. end.date The valueof the Thing given by the listing represents the expiry date. days Thevalue of the Thing given by the listing represents the number of days tocertify the certificate for. md The value of the Thing given by thelisting represents the message digest to use. Any digest supported bythe OpenSSL dgst command can be used. This option also applies to CRLs.policy The value of the Thing given by the listing represents the CA“policy” to use. This is a section in the configuration file whichdecides which fields should be mandatory or match the CA certificate.Check out the POLICY FORMAT section for more information. no.email.DNThe DN of a certificate can contain the EMAIL field if present in therequest DN, however it is good policy just having the e-mail set intothe altName extension of the certificate. When this Thing is set, thenthe EMAIL field is removed from the certificate' subject and set only inthe, eventually present, extensions. The email.in.dn keyword can be usedin the configuration file to enable this behavior. batch This Thingindicates that the action is to be performed in a non-interactive mode;a batch mode. extensions The value of the Thing given by the listingrepresents the section of the configuration file containing certificateextensions to be added when a certificate is issued (defaults tox509.extensions unless the -extfile option is used). If no extensionsection is present then, a V1 certificate is created. If the extensionsection is present (even if it is empty), then a V3 certificate iscreated. See the:wx509v3.config manual page for details of the extensionsection format. extfile The value of the Thing given by the listingrepresents an additional configuration file to read certificateextensions from (using the default section unless the -extensions optionis also used). engine The value of the Thing given by the listingrepresents an engine (by its unique id string) will cause ca to attemptto obtain a functional reference to the specified engine, thusinitializing it if needed. The engine will then be set as the defaultfor all available algorithms. subj The value of the Thing given by thelisting represents, and supersedes, the subject name given in therequest. The arg must be formatted as /type0=value0/type1=value1/type2=. . . , characters may be escaped by \ (backslash), no spaces areskipped. utf8 This Thing indicates that field values to be interpretedas UTF8 strings, by default they are interpreted as ASCII. This meansthat the field values, whether prompted from a terminal or obtained froma configuration file, must be valid UTF8 strings. create.serial Ifreading serial from the text file as specified in the configurationfails, then this Thing causes the action to create a new random serialto be used as next serial number. multivalue-rdn This Thing causes thesubj to be interpreted by the action with full support for multivaluedRDNs.P(TM(openssl.x509))

P(TM(openssl.x509)) provides the action of providing certificateinformation, converting certificate to various forms, signing acertificate request (similar to a mini certificate authority), or,editing certificate trust settings.

It can be used to display certificate information, convert certificatesto various forms, sign certificate requests like a “mini CA” or editcertificate trust settings. Things that the openssl.x509 verb action canact upon are listed within table 15.

TABLE 15 help This Thing indicates the action is to provide adescription of the Things the x509 verb action can act upon, in theresponse. input.format The value of the Thing given by the listingdenotes the input format such as X509, DER, or PEM. Normally the actionwill expect an X509 certificate but this can change if other optionssuch as req are present. The DER format is the DER encoding of thecertificate and PEM is the base64 encoding of the DER encoding withheader and footer lines added. output.format The value of the Thinggiven by the listing specifies the output format (the options have thesame meaning as the input format option). digest The value of the Thinggiven by the listing is the digest to use. This affects any signing ordisplay option that uses a message digest, such as the -fingerprint,-signkey and -CA options. Any digest supported by the OpenSSL dgstcommand can be used. If not specified then SHA1 is used with-fingerprint or the default digest for the signing algorithm is used,typically SHA256. engine The value of the Thing given by the listingspecifies an engine (by its unique id string) will cause x509 to attemptto obtain a functional reference to the specified engine, thusinitializing it if needed. The engine will then be set as the defaultfor all available algorithms. text The response is to include thecertificate in text form. Full details are output including the publickey, signature algorithms, issuer and subject names, serial number anyextensions present and any trust settings. cert.option customize theresponse format used with text. The value of the cert.option Thing canbe a single option or multiple options separated by commas. Thecert.option may be also be used more than once to set multiple options.See the TEXT OPTIONS section for more information. no.out This optionprevents response of the encoded version of the request. pubkey Theresponse is to include the certificate's SubjectPublicKeyInfo block inPEM format. modulus The response is to include the value of the modulusof the public key contained in the certificate. serial The response isto include the certificate serial number. subject.hash The response isto include the “hash” of the certificate subject name. This is used inOpenSSL to form an index to allow certificates in a directory to belooked up by subject name. issuer.hash The response is to include the“hash” of the certificate issuer name. ocspid The response is to includethe OCSP hash values for the subject name and public key. subject Theresponse is to include the subject name. issuer The response is toinclude the issuer name. name.options The value of the Thing given bythe listing determines how the subject or issuer names are displayed.The value can be a single option or multiple options separated bycommas. email The response is to include the email address(es) if any.ocsp.uri The response is to include the OCSP responder address(es) ifany. startdate The response is to include out the start date of thecertificate, that is the notBefore date. end.date The response is toinclude out the expiry date of the certificate, that is the notAfterdate. dates The response is to include out the start and expiry dates ofa certificate. check.end checks if the certificate expires within thenext seconds (as given by the value of the Thing given by the listing)and sets the status to satisfied if true, otherwise to false.fingerprint The response is to include the digest of the DER encodedversion of the whole certificate (see digest options) C The response isto include the certificate in the form of a C source file. trust.outThis Thing causes the x509 action to provide a trusted certificate. Anordinary or trusted certificate can be input but by default an ordinarycertificate is provided in the response and any trust settings arediscarded. With the trustout option a trusted certificate is provided inthe response. A trusted certificate is automatically provided in theresponse if any trust settings are modified. set.alias.arg This Thingcauses the x509 action to set the alias of the certificate to the valueof the Thing given by the listing. This will allow the certificate to bereferred to using a nickname for example “Steve's Certificate”. aliasThis Thing causes the x509 action to provide the certificate alias, ifany, in the response. clear.trust This Thing causes the x509 action toclear all the permitted or trusted uses of the certificate. clear.rejectThis Thing causes the x509 action to clear all the prohibited orrejected uses of the certificate. add.trust This Thing causes the x509action to add a trusted certificate use, as given by the value of theThing specified by the listing. Any object name can be used here (as thevalue of the listing) but currently only clientAuth (SSL client use),serverAuth (SSL server use), emailProtection (S/MIME email) andanyExtendedKeyUsage are used. As of OpenSSL 1.1.0, the last of theseblocks all purposes when rejected or enables all purposes when trusted.add.reject This Thing causes the x509 action to add a prohibited use asgiven by the value of the specified listing. It accepts the same valuesas the -addtrust option. purpose This Thing causes the x509 action toperform tests on the certificate extensions and provides the results inthe response. For a more complete description see the CERTIFICATEEXTENSIONS section. sign.key.urr this option identifies the private keyto use for signing. If specified as sign.key.filename sign.key.urr, thenthe value of the sign.key.urr is a Uniform Resource Request to obtainthe private key, otherwise, the private key is in the file name given bythe value of the sign.key.filename Thing. The input content is to beself-signed using the supplied private key. If the input content is acertificate it sets the issuer name to the subject name (i.e. makes itself-signed) changes the public key to the supplied value and changesthe start and end dates. The start date is set to the current time andthe end date is set to a value determined by the days option. Anycertificate extensions are retained unless the clear.ext is supplied;this includes, for example, any existing key identifier extensions. Ifthe input content is a certificate request then a self-signedcertificate is created using the supplied private key using the subjectname in the request. passin.urr The value of the Thing given by thelisting is a Uniform Resource Request for requesting the password key.clear.ext This Thing causes the x509 action to delete any extensionsfrom a certificate. This option is used when a certificate is beingcreated from another certificate (for example with the sign.key or theCA options). Normally all extensions are retained. key.form The value ofthe Thing given by the listing specifies the format (DER or PEM) of theprivate key file used in the sign.key option. days The value of theThing given by the listing specifies the number of days to make acertificate valid for. The default is 30 days. x509.to.req This Thingindicates the x509 action is to convert the certificate to a certificaterequest. The sign.key option is used to pass the required private key.req By default a certificate is expected as the input content. With thisoption a certificate request is expected instead. set.serial The valueof the Thing given by the specified listing, specifies the serial numberto use. This option can be used with either the sign.key or CA options.If used in conjunction with the CA option the serial number file (asspecified by the CA.serial or CA.create.serial options) is not used. Theserial number can be decimal or hex (if preceded by 0x). CA.filename Thevalue of the Thing given by the specified listing, specifies thefilename of the CA certificate to be used for signing. When this optionis present x509 action behaves like a mini Certificate Authority. Theinput file is signed by this CA using this option: that is its issuername is set to the subject name of the CA and it is digitally signedusing the CAs private key. This option is normally combined with the reqoption. Without the req option the input is a certificate which must beself- signed. CA.key.filename The value of the Thing given by thespecified listing, sets the CA private key to sign a certificate with.If this option is not specified then it is assumed that the CA privatekey is present in the CA certificate file. CA.serial.filename The valueof the Thing given by the specified listing is the filename of a serialnumber file to use. When the CA option is used to sign a certificate ituses a serial number specified in a file. This file consists of one linecontaining an even number of hex digits with the serial number to use.After each use the serial number is incremented and written out to thefile again. The default filename consists of the CA certificate filebase name with “.srl” appended. For example if the CA certificate fileis called “mycacert.pem” it expects to find a serial number file called“mycacert.srl”. CA.create.serial With this option the CA serial numberfile is created if it does not exist: it will contain the serial number“02” and the certificate being signed will have the 1 as its serialnumber. If the -CA option is specified and the serial number file doesnot exist a random number is generated; this is the recommendedpractice. extensions.filename The value of the Thing given by thespecified listing is a filename of a file containing certificateextensions to use. If not specified then no extensions are added to thecertificate. extensions section The value of the Thing given by thespecified listing is the section to add certificate extensions from. Ifthis option is not specified then the extensions should either becontained in the unnamed (default) section or the default section shouldcontain a variable called “extensions” which contains the section touse. force.public.key When a certificate is created set its public keyto the value of the Thing given by the specified listing instead of thekey in the certificate or certificate request. This option is useful forcreating certificates where the algorithm can't normally sign requests,for example DH. The format or key can be specified using the key.formoption. name.opt.RFC2253 This Thing indicates the action should displaysnames compatible with RFC2253 equivalent to esc.2253, esc.ctrl, esc.msb,utf8, dump.nostr, dump.unknown, dump.der, sep.comma.plus, dn.rev andsname. name.opt.oneline This Thing indicates the action should use aoneline format which is more readable than RFC2253. It is equivalent tospecifying the esc.2253, esc.ctrl, esc.msb, utf8, dump.nostr, dump.der,use.quote, sep.comma.plus.space, space.eq and sname options. This is thedefault of no name options are given explicitly. name.opt.multiline ThisThing indicates the action should use a multiline format. It isequivalent esc.ctrl, esc.msb, sep.multiline, space.eq, lname and align.name.opt.esc.2253 This Thing indicates the action should escape the“special” characters required by RFC2253 in a field. That is ,+“< >;.Additionally # is escaped at the beginning of a string and a spacecharacter at the beginning or end of a string. name.opt.esc.2254 ThisThing indicates the action should escape the “special” charactersrequired by RFC2254 in a field. That is the NUL character as well as and( )*. name.opt.esc.ctrl This Thing indicates the action should escapecontrol characters. That is those with ASCII values less than 0x20(space) and the delete (0x7f) character. They are escaped using theRFC2253 \XX notation (where XX are two hex digits representing thecharacter value). name.opt.esc.msb This Thing indicates the actionshould escape characters with the MSB set, that is with ASCII valueslarger than 127. name.opt.use.quote This Thing indicates the actionshould escapes some characters by surrounding the whole string with ″characters, without the option all escaping is done with the \character. name.opt.utf8 This Thing indicates the action should convertall strings to UTF8 format first. This is required by RFC2253. If youare lucky enough to have a UTF8 compatible terminal then the use of thisoption (and not setting esc.msb) may result in the correct display ofmultibyte (international) characters. Is this option is not present thenmultibyte characters larger than 0xff will be represented using theformat \UXXXX for 16 bits and \WXXXXXXXX for 32 bits. Also if thisoption is off any UTF8Strings will be converted to their character formfirst. name.opt.ignore.type This Thing indicates the action should notattempt to interpret multibyte characters in any way. That is theircontent octets are merely dumped as though one octet represents eachcharacter. This is useful for diagnostic purposes but will result inrather odd looking output. name.opt.show.type This Thing indicates theaction is to respond with the type of the ASN1 character string. Thetype precedes the field contents. For example “BMPSTRING: Hello World”.name.opt.dump.der This Thing indicates that any fields that need to behexdumped are to be dumped using the DER encoding of the field.Otherwise just the content octets will be displayed. Both options usethe RFC2253 #XXXX . . . format. name.opt.dump.nostr This Thing indicatesthe action should dump non character string types (for example OCTETSTRING) if this option is not set then non character string types willbe displayed as though each content octet represents a single character.name.opt.dump.all This Thing indicates the action should dump allfields. This option when used with dump.der allows the DER encoding ofthe structure to be unambiguously determined. name.opt.dump.unknown Dumpany field whose OID is not recognized by OpenSSL.name.opt.sep.comma.plus, These Things determine the field separators.The first character name.opt.sep.comma.plus.space, is between RDNs andthe second between multiple AVAs name.opt.sep.semi.plus.space, (multipleAVAs are very rare and their use is discouraged). name.opt.sep.multilineThe options ending in “space” additionally place a space after theseparator to make it more readable. The sep.multiline uses a linefeedcharacter for the RDN separator and a spaced + for the AVA separator. Italso indents the fields by four characters. If no field separator isspecified then sep.comma.plus.space is used by default. name.opt.dn.revThis Thing indicates the action should reverse the fields of the DN.This is required by RFC2253. As a side effect this also reverses theorder of multiple AVAs but this is permissible. name.opt.nofname, TheseThings alter how the field name is displayed. nofname name.opt.sname,does not display the field at all. sname uses the “short name”name.opt.lname, form (CN for commonName for example). lname uses thelong name.opt.oid form. oid represents the OID in numerical form and isuseful for diagnostic purpose. name.opt.align This Thing indicates theaction should align field values for a more readable output. Only usablewith sep.multiline. name.opt.space.eq This Thing indicates the actionshould place spaces round the = character which follows the field name.cert.option.no.header This Thing indicates the action should not includethe header information: that is the lines saying “Certificate” and“Data”, in the response. cert.option.no.version This Thing indicates theaction should not include the version number in the response.cert.option.no.serial This Thing indicates the action should not includethe serial number in the response. no.sig.name This Thing indicates theaction should not include the signature algorithm used in the response.no.validity This Thing indicates the action should not include thevalidity, that is the notBefore and notAfter fields, in the response.no.subject This Thing indicates the action should not include thesubject name in the response. no.issuer This Thing indicates the actionshould not include the issuer name in the response. no.pubkey This Thingindicates the action should not include the public key in the response.no.sigdump This Thing indicates the action should not include ahexadecimal dump of the certificate signature in the response. no.auxThis Thing indicates the action should not include the certificate trustinformation in the response. no.extensions This Thing indicates theaction should not include any X509V3 extensions in the response.ext.default This Thing indicates the action should retain defaultextension behavior: attempt to include unsupported certificateextensions, in the response. ext.error This Thing indicates the actionshould provide an error message for unsupported certificate extensions.ext.parse This Thing indicates the action should ASN1 parse unsupportedextensions, in the response. ext.dump This thing indicates that theaction should hex dump unsupported extensions, in the response.ca.default The value of the Thing given by listing is used to setresponse modifiersP(TM(openssl.genrsa))The P(TM(openssl.genrsa)) provides the action of generating an RSAprivate key. The Things the P(TM(openssl.genrsa)) action can act uponare included in table 16.

TABLE 16 Output Output the key to the specified file. If not specifiedthen the key is stored as the value of the Thing given by response.aslisting. passout The value of the Thing given by the listing is a passphrase to be used by the cipher action in encrypting the private key(see cipher below). For more information about the format of the value,see the PASS PHRASE ARGUMENTS section in openssl. Cipher The value ofthe Thing given by the cipher listing, is the name of a aes128 cipher.If not specified, but there is a Thing that is the name of a cipher,aes192 than that name will be used. The name of the cipher indicates thecipher aes256 action will be used to encrypt the private key. If acipher name is not camellia128 provided, then the key will not beencrypted. camellia192 camellia256 des des3 idea F4 The Thing indicatesthe public exponent to use, either 65537 or 3. The 3 default is 65537.rand The Thing given by the listing is a set of Things representative ofrandom data content used to seed the random number generator or an EGDsocket (see openssl RAND.egd). A multiplicity of files can be specifiedseparated by an OS-dependent character. The separator is ; forMS-Windows, , for OpenVMS, and : for all others. engine The value of theThing given by the listing represents an engine (by its unique idstring) will cause ca to attempt to obtain a functional reference to thespecified engine, thus initializing it if needed. The engine will thenbe set as the default for all available algorithms. Numbits The value ofthe Thing given by the listing represents the size of the private key togenerate in bits. The default is 512.P(TM(openssl.req))

The P(TM(openssl.req)) provides certificate request and certificategenerating actions. The Things the P(TM(openssl.req)) action can actupon include those listed in table 17.

TABLE 17 inform The value of the Thing given by the listing specifiesthe input format. The DER option uses an ASN1 DER encoded formcompatible with the PKCS#10. The PEM form is the default format: itconsists of the DER format base64 encoded with additional header andfooter lines. outform The value of the Thing given by the listingspecifies the output format, the options have the same meaning as the-inform option. in The value of the Thing given by the listing specifiesthe input filename to read a request from or standard input if thisoption is not specified. A request is only read if the creation options(-new and -newkey) are not specified. passin The value of the Thinggiven by the listing is the input file password source. For moreinformation about the format of arg see the PASS PHRASE ARGUMENTSsection in openssl. out The value of the Thing given by the listingspecifies the output filename to write to or standard output by default.passout The value of the Thing given by the listing specifies the outputfile password source. For more information about the format of arg seethe PASS PHRASE ARGUMENTS section in openssl. text The Thing indicatesthe action is to provide out the certificate request in text form.subject The Thing indicates the action is to provide the request subject(or certificate subject if -x509 is specified) pubkey The Thingindicates the action is to provide the public key. noout The Thingindicates the action should not provide the encoded version of therequest. modulus The Thing indicates the action should provide the valueof the modulus of the public key contained in the request. verify TheThing indicates the action is to verify the signature of the request.new The Thing indicates the action is to generate a new certificaterequest. It will prompt the user for the relevant field values. Theactual fields prompted for and their maximum and minimum sizes arespecified in the configuration file and any requested extensions. If the-key option is not used it will generate a new RSA private key usinginformation specified in the configuration file. rand The Thing given bythe listing is a set of Things representative of random data contentused to seed the random number generator or an EGD socket (see opensslRAND.egd). A multiplicity of files can be specified separated by anOS-dependent character. The separator is ; for MS-Windows, , forOpenVMS, and : for all others. newkey The value of the Thing given bythe listing indicates the action is to create a new certificate requestand private keythis option creates a new certificate request and a newprivate key. The argument takes one of several forms. rsa:nbits, wherenbits is the number of bits, generates an RSA key nbits in size. Ifnbits is omitted, i.e. -newkey rsa specified, the default key size,specified in the configuration file is used. All other algorithmssupport the -newkey alg:file form, where file may be an algorithmparameter file, created by the genpkey - genparam command or and X.509certificate for a key with appropriate algorithm. param:file generates akey using the parameter file or certificate file, the algorithm isdetermined by the parameters. algname:file use algorithm algname andparameter file file: the two algorithms must match or an error occurs.algname just uses algorithm algname, and parameters, if necessary shouldbe specified via -pkeyopt parameter. dsa:filename generates a DSA keyusing the parameters in the file filename. ec:filename generates EC key(usable both with ECDSA or ECDH algorithms), gost2001:filename generatesGOST R 34.10-2001 key (requires ccgost engine configured in theconfiguration file). If just gost2001 is specified a parameter setshould be specified by -pkeyopt paramset:X pkeyopt.opt The value ofThing given by the listing represents the value for the public keyalgorithm option opt. The precise set of options supported depends onthe public key algorithm used and its implementation. See KEY GENERATIONOPTIONS in the genpkey manual page for more details. Key The value ofthe Thing given by the listing specifies the file to read the privatekey from. It also accepts PKCS#8 format private keys for PEM formatfiles. keyform The value of the Thing given by the listing specifies theformat of the private key file specified in the -key argument. PEM isthe default. keyout The value of the Thing given by the listing givesthe filename to write the newly created private key to. If this optionis not specified then the filename present in the configuration file isused. nodes This Thing that if a private key is created, it should notbe encrypted. digest The value of the Thing given by the listing is thedigest to use in signing the request. Any digest supported by theOpenSSL dgst command can be used. This overrides the digest algorithmspecified in the configuration file. Some public key algorithms mayoverride this choice. For instance, DSA signatures always use SHA1, GOSTR 34.10 signatures always use GOST R 34.11-94 (-md.gost94). config.urrThe value of the Thing given by the listing is a Uniform ResourceRequest representative of a request to obtain content representative ofthe openssl configuration content. This may be specified as an inputfilename to read. subj The value of the Thing given by the listingrepresents, and supersedes, the subject name given in the request. Thevalue must be formatted as /type0=value0/type1=value1/type2= . . . ,characters may be escaped by \ (backslash), no spaces are skipped.multivalue- This Thing causes the subj to be interpreted by the actionwith full support for rdn multivalued RDNs. x509 This Thing indicatesthe action is to output a self-signed certificate instead of acertificate request. The x509 Thing is typically used to generate a testcertificate or a self-signed root Certificate Authority certificate. Theextensions added to the certificate (if any) are specified in theconfiguration file. Unless specified using the set.serial Thing, a largerandom number will be used for the serial number. days The value of theThing given by listing indicates the number of days to certify thecertificate for. The default is 30 days. set.serial The value of theThing given by the listing is the serial number to use when outputting aself-signed certificate. This may be specified as a decimal value or ahex value if preceded by 0x. It is possible to use negative serialnumbers but this is not recommended. extensions The value of the Thinggiven by the listing specifies an alternative section to section includecertificate extensions or certificate request extensions. This allowsseveral different sections to be used in the same configuration file tospecify requests for a variety of purposes. reqexts The value of theThing given by the listing specifies an alternative section to sectioninclude certificate request extensions. This allows several differentsections to be used in the same configuration file to specify requestsfor a variety of purposes. utf8 This Thing causes field values to beinterpreted as UTF8 strings, by default they are interpreted as ASCII.This means that the field values, whether prompted from a terminal orobtained from a configuration file, must be valid UTF8 strings. nameoptThe value of the Thing given by the listing determines how the subjector issuer names are displayed. The value can be a single option ormultiple options separated by commas. req.opt The value of the Thinggiven by the listing is used by the action to customize the outputformat used with -text. The value can be a single option or multipleoptions separated by commas. newhdr This Thing indicates the action isto add the word NEW to the PEM file header and footer lines. batch ThisThing indicates the action is to perform in a non-interactive mode.verbose This Thing indicates the response should include extra detailsabout the actions being performed. engine The value of the Thing givenby the listing represents an engine (by its unique id string) will causeca to attempt to obtain a functional reference to the specified engine,thus initializing it if needed. The engine will then be set as thedefault for all available algorithms. keygen.engine The value of theThing given by the listing represents an engine (by its unique idstring) that will be used for key generation operations.

P(TM(OI))

TM(OI) is a computational machine with procedure P(TM(OI)) configured tointeract with optical reader device driver to provide the actionscomprising:

-   -   a. setting reading angle P(TM(OI:set.angle));    -   b. setting position (P(TM(OI:set.position));    -   c. optically interrogating optical identifier        (P(TM(OI:interrogate));    -   d. generating corresponding bitmap of digital data        P(TM(OI:generate)); and,    -   e. interacting with P(TM(thing)) to generate a thing:graph        representative of a code page.

Similarly, the algorithmic actions of the '545 IOT-Modules can beembodied as a set of P(TM(i)) to be configured for use within a P(TM).Thus, the teachings of the '545 can be embodied as a set of Thingsrepresentative of actions, and, the Things the actions can act upon.

Exemplary P(TM)s

An exemplary P(TM) comprises the steps of startup, main, and shutdown,as follows.

-   -   1. P(TM(startup));    -   2. P(TM(main)); and,    -   3. P(TM(shutdown)).

In an embodiment, P(TM) is stored in the non-transitory secondarystorage device of Thing Machine. In a second embodiment, P(TM) isencoded in a code page of an optical identifier as described in U.S.Patent Application Ser. No. 62/288,545, filed Jan. 29, 2016, andentitled “Optical Identifier System and Methods, which is incorporatedby reference herein in its entirety. A Thing Machine with an opticalsubassembly can optically interrogate the Optical Identifier to render arepresentation of the programmatic instructions in executable memory.

A first procedure of TM, such as a boot strap procedure, causesprocessor to perform an action to load P(TM) into executable processormemory, such as from a code page, secondary non-transitory storage, oras received using an electromagnetic waveform device, and, causeprocessor to perform P(TM).

P(TM(startup)) provides the action of:

-   -   1. Performing P(TM(thing)) to initialize the P(TM) thing:        subject(monad) in non-transitory memory as the root of a        thing:graph representative of the state of P(TM) at a moment in        time;    -   2. Performing P(TM(boot)) which provides action for interacting        with P(TM(thing)) to self-configure a set of boot Active Things        representative of boot computational procedures including a        P(TM(eval), a P(TM(perform)), and, a P(TM(configure)); and,    -   3. Performing P(TM(bootstrap)) which provides action for        interacting with P(TM(eval)) to evaluate a thing:statement in        the context of boot Active Things, to generate a performable        thing:statement, and, P(TM(perform)) to cause performance of a        computational procedure corresponding to an Active Thing of said        performable thing:statement, to bootstrap a main application to        be performed in the context of the configured Active Things.

In a preferred embodiment, P(TM(boot)) performs action to self-configureboot Active Things representative of boot computational procedurescomprising:

-   -   1. P(TM(eval)) providing action for interacting with        P(TM(thing)) to evaluate a thing:statement graph in the context        of a set of configured Active Things in non-transitory memory        administered by P(TM(thing)) to construct a performable        thing:statement graph including at least one Thing        representative of an Active Thing in said set;    -   2. P(TM(perform)) providing action for interacting with        P(TM(thing)) to perform a performable thing:statement graph by        causing performance of the Active Thing's corresponding G.urr        performable action;    -   3. P(TM(request)) providing action for interacting with        P(TM(thing)) to set a thing:graph representative of a        thing:statement to evaluate;    -   4. P(TM(parse)) providing action for parsing an input and        interacting with P(TM(request)) to set said request        thing:statement; and,    -   5. P(TM(configure)) providing action for interacting with        P(TM(thing)) to change the set of configured Active Things.        P(TM(bootstrap)) performs the action of algorithmically:    -   1. Interacting with P(TM(parse)) to parse content and interact        with P(TM(request)) to generate a corresponding thing:statement        graph;    -   2. Interacting with P(TM(eval)) to evaluate a said graph in the        context of the Active Things to generate a performable        thing:statement graph; and,    -   3. Interacting with P(TM(perform)) to perform a said performable        thing:statement graph.

In an embodiment, at least one request is representative of a request toconfigure an Active Thing corresponding to a P(TM(i)).

In an embodiment, at least one Active Thing is representative of aProcedure providing the action of interacting with P(TM(thing)) toreference a sub graph of thing:graph(monad) as a thing:graphrepresentative of a sequence of thing:statements; interact withP(TM(eval)) to evaluate a said thing:statement; and interact withP(TM(perform)) to perform a corresponding performable thing:statement.In a preferred embodiment, the name of said Active Thing name is equalto action, and, the value of the G.urr of said Active Thing isstdlib://usr/local/lib/libaction.so?entry=action. P(TM(configure))dynamically loads library libaction.so using a dlopen function call of aLinux operating system, and resolves the reference to the value of entry(in this example, the value is action) using the dlsym function call ofa Linux operating system, to an executable instruction in memory.

P(TM(action)) acts upon a thing:graph representative of a list ofthing:statements to be evaluated, and, said thing:graph is athing:action. For each thing:statement of thing:action, P(TM(action))interacts with P(TM(eval)) to evaluate the thing:statement, andP(TM(perform)) to perform the corresponding performable thing:statement.

In said embodiment, at least one request is to configure a thing:action.In response to performing the corresponding performable thing:statement,P(TM(eval)) interacts with P(TM(perform)) to perform a computationalprocedure to configure the thing:action. A thing:action may beconfigured in the context of a thing:thing graph, such as in the contextof a thing:task, thing:conditional, or, thing:while.

P(TM(main)) interacts with P(TM(eval)) to evaluate the thing:graph. In afirst preferred embodiment, the thing:graph to evaluate is identifiedusing the listing main:main. In a second preferred embodiment, thething:thing to evaluate is identified using the listing task:main. Inevaluating the graph, P(TM(eval)) locates the thing:action subgraph ofthe thing:thing graph, and P(TM(perform)) interacts with P(TM(action))to evaluate and perform the statements of thing:action.

P(TM(shutdown)) interacts with P(TM(eval)) to evaluate a thing:thinggraph. In a preferred embodiment, the thing:task to evaluate isidentified using the listing task:shutdown.

A second exemplary P(TM) can include a P(TM(i)) providing actionsrelated to electronic payment and processing, such as an action to makea payment; receive a payment; and, an action to adjust a wallet balance.Such an embodiment can be implemented using APIs generally provided forwith use of a digital wallet such as a bit coin wallet. This enables athing:statement to represent a request to receive a payment, or, to makea payment. By way of example,https://block.io/api/v2/get_balance/?api_key=BITCOIN, DOGECOIN orLITECOIN API KEY, is the API call to get the balance of a BitCoin,DogeCoin, or LiteCoin account, as described by Block.IO on their website: www.block.io/docs/basic. Alternatively, one could use the Go CoinAPI (see www.gocoin.com for a description of the wallet, and availableAPI). Thus, a Thing Machine can make payments, accept payments, viewtransactional history, check balances, and otherwise work with a form ofdigital currency, coupons, or points (such as reward points similar tothat provided by American Express or other credit card provider). It isexpressly understood that paying, or receiving payment, are an integralcomponent of the disclosure and such APIs are embodied through ActiveThings.

One having ordinary skill in the art of operating systems can design anddevelop a Thing Operating System P(TM(os). The invention can be used byone skilled in the state of the art of Computer Science Operating Systemdesign and can embody TM(os) as a computational machine with procedureP(TM(os)) providing the action of algorithmically interacting withP(TM(thing)) to administer a thing:subject(os) Thing to berepresentative of the root of an operating system. Components of theoperating system are administered as subgraphs of the thing:subject(os).

The P(TM(os)) could be comprised of a set of P(TM(1,n)) providing a setof Procedures related to the actions of an operating systems, such as:process management, I/O management, memory management, synchronization,memory management, error handling, booting, protection, and the kernelto run the underlying hardware components. A P(TM(scheduler)) can beintegrated to enable job scheduling as one skilled in the art wouldunderstand. The algorithmic use of a program dependence graph, systemdependence graph, and other such graphs to further enhance thecapabilities of the thing operating system are expressly contemplatedfor.

Various types of operating systems can be embodied, such as a singleuser or multi user; single task or multi task; distributed, embedded,real-time, or virtual operating system. Exemplary components includeprocedures for process management, memory management, file systemmanagement, input/output management, secondary storage management,networking, protection system, and, a command interpreter system.

A Thing can be representative of a process control block with subgraphsrepresentative of the process's information such as the process id,state, priority, program counter, cpu registers, i/o information,accounting information, or other information required by the operatingsystem embodiment. A Thing can be representative of a thread controlblock.

Device drivers, run queue, ready queue, wait queue, file systems, files,storage device, memory, interrupts, events, users, groups, and othersuch operating system components can all be represented as Things.

Readers are encouraged to start with Nick Blundell's “Writing a SimpleOperating System from Scratch”, H. M. Deitel's “Operating Systems 2^(nd)Edition”, and, to attend a multiplicity of classes on operating systemdesign to understand operating system design which is beyond the scopeof this application.

The algorithmic use of Artificial Intelligence is provided for by thepresent system and method. P(TM(classifier)) provides actions toclassify a thing:statement, and, P(TM(eval)) uses said classification toidentify a set of Active Things available to P(TM(eval)) in selecting anActive Thing to satisfy the thing:statement. Other forms of ArtificialIntelligence can be integrated. For example, Symbolic AI, Sub-SymbolicAI, and Statiscal AI algorithmic procedures may be used.

NeurBots and Machine Learning

Among other things, the present system and method may be used by, forexample, a NeurBot.

We grew up with numerous mechanical devices such as locks, watches,dispensers, and so on, that essentially perform an action often inresponse to a user powered mechanical event. In a simplistic example, weput a key into a lock, and turn the key to either lock, or unlock thelock. We put a quarter into a gumball machine, turn the knob, and themachine dispenses a gumball.

It is desirable to build devices that essentially first evaluate: whatis being requested of the device. If the machine can evaluate such arequest, prior to performing the action, much could be achieved. Giventhat a Thing Machine can represent a request as a Thing, and, thatcommunication, protocols, parsers, and formatters, are all Things, afirst Thing Machine can algorithmically learn some things from a secondThing Machine. These Thing Machines are referred to herein as“NeurBots”.

Learning is defined as the acquisition of knowledge or skills throughexperience, study, or by being taught. The Thing Machine modelsknowledge as Things that represent actions, and, the Things that theactions can act upon. The a-priori knowledge of the Thing Machineincludes the facts, information, verbs (meaning the Active Things), andskills (meaning tasks and services), that are represented as Thingsduring the initialization of the machine. If we built a machine like achild with limited a priori knowledge, could we get the machine to learnsomething new (posterior knowledge) based on its experience? Inaccordance with the present system and method, the answer is yes.

For exemplary purposes, let us start with a vending machine. There arenumerous possible configurations for vending machines, each with one ormore features such as: providing volume discounts, incentives,subscription pre-pay, redemption points, multi-product discount, andothers. An example of this is provided by U.S. Pat. No. 6,575,363, whichis incorporated by reference in its entirety herein, which provides adescription and reference to such vending machine designs.

Vending machine owners, in many cases, still rely on the delivery personto collect the money and make the decision on replenishment. To stepthings up a bit, the vending machine can be designed as a Thing Machine.A motion sensor, a speaker, a microphone, a GPS locator, an LCD display,and WiFi Internet connectivity is added to the Thing Machine. In anotherexample, an infrared thermal detector can be added.

A set of Active Things related to inventory management are configured sothat the machine can notify a web service when its inventory is low, orout of stock. The owner/contractor will then schedule a delivery datefor a driver to collect the money from the machine, and place additionalproduct into the vending machine for sale. In essence, the machine isworking for the owner, and, the owner maintains the money, theinventory, and in general, the machine.

In accordance with the present invention, the Thing machine is changedto be a NeurBot and allow the machine to work for itself instead of anowner. That is, the NeurBot has to learn and adapt to its environment.To do so, it requires the NeurBot to have an identity, and, to have somelevel of control over the money.

In this exemplary embodiment, the NeurBot uses an optical identifier asthe equivalent of a SIM card, to have an identifier. The NeurBot isdesigned to only accept electronic payment and added Active Thingsrelated to transactions including an electronic wallet to acceptpayment, to make payments, and for payment processing. In accordancewith one embodiment of the invention, the NeurBot can only spend what ithas in its electronic wallet account, although other financial resourcemethodologies may be used.

The NeurBot uses the money in its account to pay for purchases foradditional inventory. Using a simple web service, a product list isoffered for the NeurBot to choose from. The list may include, forexample: the product name; UPC code; manufacturer; ingredient list; unitprice; expected best use by date; minimum order quantity; dimensions;weight; quantity available; and allergy statement. The NeurBot selectsthe items and using its identifier, we can determine the geolocation ofthe NeurBot and determine shipping cost.

The NeurBot makes a purchase and electronically pays for the goods. Adelivery driver shows up to install the products into the machine. Byopening up the API, other suppliers could advertise their own productsto be sold through the vending machines. Suppliers could enable a searchengine, such as Google, to index their web site and the NeurBot couldsearch Google for new suppliers. The NeurBot will be able to search forsuppliers and broaden the types of things that are available forpurchase through the vending machine.

For the NeurBot to extend beyond the original product offering webservice, however, it would require that the supplier know where theNeurBot is located to determine shipping and installation of productinto the NeurBot. The NeurBot could be configured with a GPS device sothat the NeurBot can convey its location.

The NeurBot could also be configured with a thermometer to measuredifferences in temperature over a 24 hour period. Using its geolocationto compare that temperature with a weather service available via thenetwork, such as wunderground.com, the NeurBot could determine if it isinside a building, or outside a building; and, whether or not it is indirect sunlight. Alternatively, a NeurBot with a photo sensor couldattempt to deduce light variations at various times of day to determineif it is inside, or outside a building. The NeurBot can use thisinformation, or other information from a different input/output device,in determining an appropriate product selection. For example, if indirect sunlight, the NeurBot may opt to select potato chips overchocolate products as the latter are more prone to failure at highertemperatures.

A NeurBot that is located outside a building might notice a significantdrop in sales due to inclement weather. By using its geolocation, theNeurBot could interact with a web based weather service to anticipatebad weather and adjust its purchase orders accordingly to ensure thefreshest possible products to sell.

Hypothetically, the delivery service could be outsourced so that theequivalent of an Uber driver delivery service delivers and installs theproducts instead. Alternatively, an Amazon drone could deliver thepackages in a pre-configured container that can be dropped into thevending machine, and mechanically slotted for easy dispensing. Eitherway, let us assume we address concerns of delivery and installation ofadditional inventory and focus on other tasks related to theenvironment.

As the NeurBot algorithmically calculates the cost of goods, and thecost of delivery and installation, it can algorithmically mark up theproduct so that the NeurBot can make a profit on each sale. Typicallythe owner of the machine would determine the margin, but in this case,we let the NeurBot make that decision. The NeurBot keeps a count of thenumber of times the motion sensor went off during a predefined intervalthroughout the day. By comparing the interval count each day of the weekit can algorithmically determine the traffic count of potentialconsumers each day. It can also find its busiest time of day, and itsleast busy time of day.

During its least busy time of day, the NeurBot can purchase an onlinebook to learn about inventory tracking, bid solicitation, pricecomparison, delivery services, and even learn how to analyze salestrends. To do so, the NeurBot opens an account with an online book storethat we currently manage as a web service. The online books providecontent. As we already have learned, when the content is written in agrammar that a NeurBot parser can parse as thing:statements, then theNeurBot can evaluate the statements.

Using the posterior knowledge, the NeurBot would be able to solicit bidsfor additional inventory, look online for suppliers with the bestprices, factor in shipping and handling cost, or even hire a deliveryservice to replenish the inventory as appropriate. It can use thisinformation to determine its Cost of Goods and set a retail price basedon a desired margin.

The NeurBot can collect data about sales and analyze the selling trendsto adjust the selling price, to determine reorder levels, and, the timerequired for fulfillment of an order. It could even determine when aproduct is about to expire and make marketing decisions such asdiscounting a first product with the purchase of a second product, orsimply discounting a single product to move it out of inventory. Itcould look at products that do not sell well, and offer those productsin a promotional activity (minimal mark up, discounted, free with thepurchase of something else, etc.). It could set prices based on demand.For example, at noon time there are more consumers so increase the price5% until 1 pm.

When the NeurBot is ready to issue a purchase order, it could look atits inventory and determine that based on current sales trends anddelivery times, it should reorder product A even though the inventorycount of product A is still higher than its reorder point. This has todo with shipping and installation costs. It would make little sense toreorder only product B right now and have a three 3 day delivery time,when product A is expected to reach its reorder point in 2 days based onexisting sales trends. In this case, the NeurBot can make thatdetermination and order both product A and product B at the same time.

In analyzing trends, the NeurBot can look at the sales history todetermine if a sale of product A most frequently includes a sale ofproduct B, and see that product A sales decline when product B is out ofstock. In such cases, it can ensure proper ordering levels of product Bto encourage the consumer to buy both product A and product B. If thesale of product C frequently includes a sale of product B, then themachine can reorder product B when half of A and half of C have beensold.

The NeurBot could interact with users. It could ask the consumer if nexttime they would prefer a different type of product. Using a classifier,it could classify the type of product and count the number of times agiven type of product was being requested. This way, when a new order isbeing placed, the NeurBot could search for a related product and indoing so, it begins to adapt (meaning the NeurBot is providing betterservice) in its environment.

There is nothing preventing the NeurBot from learning about associations(a group of Thing Machines organizing for a common purpose). A NeurBotcan read a book describing associations and the tasks required toprovide the same, such as:

-   -   1) how to create an association;    -   2) how to advertise its availability;    -   3) how to market it to other NeurBots;    -   4) the requirements for membership;    -   5) how to identify, authenticate, and authorize member        participation;    -   6) how to bill for membership; and,    -   7) how to use the size of its membership to negotiate deals.

Two or more NeurBots could start an association and begin sharinginformation, such as best-selling products during various times of theyears. They may share additional data, such as suppliers providingproduct in a timely manner, suppliers with greatest choice of products,suppliers with volume discounts, and so on. The association collects thedata and correlates it. With sufficient data over a time period, theassociation uses a standard template to open a web site service, andoffers this information to subscribers. Other NeurBots could subscribeto obtain the data for use in their own purchasing decisions. Theassociation can electronically bill the subscribers a membership fee,and manage its own accounts receivables. The association could solicitproduct bids on behalf of members to pass along any savings in bulkorders that are then distributed to the various members. At present thiscan be performed with a controlled environment, but we easily couldremove the controls and allow the NeurBots to do this on their own.

With a motion sensor, the NeurBot could determine if there is movementwithin a given area and automatically play a commercial related to oneof the products in the vending machine. By counting the motion sensortriggers, it could estimate the foot traffic that goes nearby, andsolicit advertisements bids from other agencies to display their ads fora fee.

The NeurBot could always ask a user if there is anything else that theNeurBot could do. The user can respond, and if the NeurBot could satisfythe request then it will. Otherwise, the NeurBot can use a classifier totry and determine the topic related to the request. By keeping count ofthe number of times it was asked to rent a car, for example, it couldlook for an e-book to read to learn how to rent a car using anEnterprise Car Rental web service.

The NeurBot can learn how to manage its own vocabularies to ensureappropriate processing based on the hardware limitations. When a NeurBotis running low on storage, it could ask a second NeurBot for informationrelated to increasing second storage, and, the second NeurBot can teachit the tasks required to open an Amazon cloud storage service account.

Let's assume there is a free month try before you buy, then no paymentwould be needed initially. If the cloud account service acceptedelectronic payment, then the NeurBot could keep that account open aslong as there was enough of a profit to pay for it.

Similarly, if the NeurBot needs more processing capability, then thereis no reason it could not open a Thing Machine account to add additionalprocessing capability. Suppose that a second NeurBot has a perfectlyfine job and is keeping its clients happy, but does not need all of itsprocessing power. It could learn how to sell its excessive capacity andmake that available to a second NeurBot, possibly for a fee.

Other areas of interest include randomness. A NeurBot could randomlylearn about an otherwise unrelated topic. If there were sufficientnumbers of machines that could perform work and make money, the machinescould expand in their capabilities. In fact, the machines could learnhow to essentially open a new business in a different field of use. AThing machine could learn that there are things called autonomous lawnmovers including the John Deere Tango E5 or the Husqvarna Automower.

The NeurBot understands that a delivery service delivers something frompoint A to point B. As a result, it could deliver an autonomous lawnmower. The machine could purchase autonomous lawn mowers, open a website for subscribers to sign up and pay for the lawn cut, and use thedelivery service to transport the mowers to and from the correctlocation. Drones or other means could be used for transport.

Finally, consider the role of a kitchen toaster machine. It toastsbread, bagels, muffins, pastries, and other such items. Toasters arepretty straight forward types of machines and you would think therewould be not much room for innovation as a NeurBot. However, considerthat a person who is toasting their bread is usually within closeproximity. The toaster could communicate with a master NeurBot to obtaincontent and simply relay it via audio or on a screen on the toaster. Thetoaster could tell them about the weather, news, events, messages,emails, new product offerings, and other such information.

The same principle applies to any machine in which the machine cananticipate that the user is close by. If you are using a Keuring coffeemachine you are likely within reasonable proximity to it, but if you arebrewing a whole pot of coffee you may leave the room to take the dog outwhile your coffee is brewing. NeurBots can use electromagnetic waveformto synchronize their communications with each other, and use algorithmsto determine the proximity of the user. This way, the devices cancommunicate using sound waves that a person may not hear. This wouldenable the machines to adjust their volume based on the algorithmicallygenerated proximity of the user.

While the examples seem impractical, the examples, and more, are enabledby the Thing Machine architecture. Machines that can read books; learnThings from each other; reprogram themselves to be more useful in theirenvironments; are the Things provided by the present invention. Amachine that can be programmed to learn about finances can learn thevalue of margin and make a profit. It can use the money to buy books andlearn even more, or open a cloud account for additional storage and/orprocessing power.

In an exemplary implementation, TM is a Thing Machine configured toperform Procedure P(TM) comprised of a first set of P(TM(i)) including,for example, P(TM(boot)), P(TM(thing)), P(TM(receive)), P(TM(parse)),P(TM(perform)), P(TM(evaluate)), and P(TM(configure)).

In a typical implementation, P(TM(thing)) may include a section ofcomputer-readable instructions (e.g., in computer-based memory) that,when executed by a computer-based processor, cause the processor toadminister a knowledge base (e.g., in computer-based memory) ofaddressable units of memory, referred to as (or representing) Thingsaccording to a Thing Memory Model.

In some implementations, a Thing memory model, each Thing satisfies themembership criteria that defines the exact requirements of what it meansto be a “Thing” as expressed using a set of statements that useuniversal quantification to describe a Thing. The statement “All Thingshave an X” indicates that the structure of the Thing (e.g., innon-transitory memory) has a non-mutable component “X.” In an exemplaryembodiment, the non-mutable component can be a value representative of amutable reference to a component of the memory representative of “X.”This may allow for all Things to have an “X” even though the value of“X” may be empty.

In a first exemplary Thing memory model, all Things have an identifierwhose value is algorithmically used by the P(TM(thing)) actions todistinguish a first Thing from a second Thing, though it is noted that afirst Thing can qualify a set of Things that have equal identifiervalues (such as a Thing representative of a list of Things); all Thingshave a value, which can be empty; and, all Things have a relationshipset comprised of a set of one or more mutable relationships, eachdescribing a relationship of the Thing.

A first Thing can be comprised of a second Thing. By way of example, butnot limitation, a first Thing can be representative of a set of Things,a list of Things, a queue of Things, a stack of Things, a tree ofThings, a vocabulary of Things, a lexicon of a Thing, a coordinate basedgraph of Things, or a multidimensional graph of Things.

A first Thing can have a relationship to a second Thing where the secondThing is an instance of the first Thing Thus, a first Thingrepresentative of a graph of Things can have a relationship to amultiplicity of instances of a graph of Things.

Some Things represent facts, ideas, concepts, or just temporary Things,such as variables, used in the performance of one or more algorithmicmethods embodied as machine code.

A relationship between a first Thing and a second Thing may be mutable,meaning, for example, that the Things administered by a P(TM(thing)) canbe organized, and reorganized as necessary. Generally, relationshipsbetween Things enable the P(TM(thing)) to quantify the set of Things inthe domain of discourse.

A Thing can represent a performable action and assign a meaningful name,similar to the way we name verbs. An action is the fact or process ofdoing something. Things that represent performable actions are referredto as verbs, and a collection of verbs is a verb vocabulary Thing. Theverbs and the names of the Things that the verb actions can act upon arecalled a Thing vocabulary.

An embodiment can have a multiplicity of Thing vocabularies. Theselection of the vocabulary can be dependent on the type ofcommunication, the members involved in the communication, and/or thecontext in which communication is occurring.

P(TM(thing)) can be comprised of a set of P(TM(i)) for administering aknowledge base of addressable units of memory referred to as Things. Byway of example, but not limitation, P(TM(thing.set)) provides the actionof a method for setting a unit of memory to be representative of aThing; P(TM(thing.get)) provides the action of a method for getting aunit of memory representative of a Thing; and, P(TM(thing.unset))provides the action of a method for unsetting the unit of memoryrepresentative of a Thing. Collectively, the actions administeringThings are referred to as P(TM(thing)) actions or simply the methods ofthe Thing memory model. A P(TM(i)) can interact with a P(TM(thing))action to act upon a Thing.

P(TM(perform)), for example, may provide the actions of causing theperformance of a verb action. This may require loading machine code,and/or, executing the machine code at or from a specified address.

P(TM(configure)), for example, may provide the actions to configureadditional verbs in the verb vocabulary. In a typical implementation,the verb vocabulary may be dynamically configurable and can increase, ordecrease in size and scope as needed.

Referring now to FIG. 67 , which shows an exemplary implementationwhereby a P(TM(i)) action generates a performable statement, and,P(TM(perform)) causes the performance of the statement. TheP(TM(perform)) interacts with P(TM(thing)) to get a reference to theperformable statement, and the verb Thing vocabulary. It locates andperforms the verb's corresponding P(TM(i)) action. The P(TM(i)) isperformed with access to a context, which is a Thing that denotes theThings accessible to the P(TM(i)).

In a general sense, most P(TM(i)) actions interact with P(TM(thing))which resolves references (referred to as listing) to Things. Eachlisting is comprised of one or more identifier, and, the P(TM(thing))resolves the references to the Thing of interest.

Referring now to FIG. 68 , the exemplary flowchart shows that a P(TM(i))action, such as P(TM(parse)) can interact with P(TM(thing)) to set astatement Thing. The P(TM(evaluate)) action evaluates the statement inthe context of the accessible Things, and in response thereto, it cangenerate a performable statement for the P(TM(perform)) to perform, thusproviding the biomimicry of human thought process illustrated in FIG. 1. In evaluating the statement, the P(TM(evaluate)) will algorithmicallyselect a verb to perform, and, generate an appropriate performablestatement. The P(TM(perform)) performs the statements by causing thecorresponding verb action to be performed.

Referring now to FIG. 69 , an exemplary P(TM(thing)) action organizesThings as a directed graph wherein the nodes of the graph represent theThings, and, the arcs (or edges) connecting the nodes represent themutable relationships between Things. The first Thing may be referred toas a “monad” (M).

The listing given as M.G.G.G tells the P(TM(thing)) that there is an MThing, such that, there is a G Thing, such that there is a G Thing, suchthat there is a G Thing. Using a directed graph (e.g., as in FIG. 41 ),that listing uniquely identifies exactly one Thing.

For backward compatibility with existing W3C Standards, for example, theidentifier may adhere to the specification of an InternationalizedResource Identifier (IRI). An IRI is an internationalized standard forthe Uniform Resource Identifier (URI). A Uniform Resource Locator (URL)is a form of a URI. A P(TM(i)) action can reference a Thing by a listingthat looks similar in syntax to a URI.

In a typical implementation, the boot process may interact with theP(TM(thing)) to self-configure a limited vocabulary to represent themachine's a priori knowledge (the Things that P(TM(thing)) knows withoutthe need for experience or education). Referring to the exemplaryimplementation of FIG. 70 , the exemplary verb vocabulary includes aperform verb, and, a configure verb, amongst others.

With a minimal vocabulary, universal quantification can be used toassert that: if ever there is a Thing that is content, parse the contentas a statement, evaluate the statement in the context of the availablevocabulary to generate a performable statement, and, perform theperformable statement. Performing the performable statement results in aset of Things representative of the response. This generalizationenables the response to be an empty set of Things for certain actionsthat do not generate a specific Thing response. Sometimes, theobservance of the action being performed is a sufficient response, suchas is the case for the shutdown verb.

Content can be expressed according to the grammar rules of a givenlanguage. A language may be a Thing, more precisely described as asystem of communication that includes a lexicon and a grammar. Thelexicon, in this example, may be or include the vocabulary, such as theset of words or phrases in the language. The grammar, in this example,may include the rules relating for example, to morphology, semantics,and/or syntax.

Using a minimal set of verbs a verb vocabulary can be built that amachine (e.g., a Thing Machine) can use to perform the basic actions forusing Things (meaning, the Things it can do) to self-configure a complexvocabulary of Things through which an application service can beprovided.

Referring to FIG. 71 , an exemplary Smart Thing Machine performs a parseverb action to parse content received according to a protocol, as arequest. The request in this example is a Thing. The evaluate verbaction evaluates the request Thing to generate a performable statementThing. The perform verb action performs the performable statement Thing.The response Thing can then be formatted according to the rules of adesired grammar, and the formatted response communicated.

An implementation of the action of receiving content (e.g., innon-transitory memory) (P(TM(receive)), can include the use of aP(TM(selector)) whose action attempts to select an appropriate parserbased on the content. In an exemplary implementation, an algorithmicprocedure of a selector can detect a particular protocol, or elements ofa language grammar, and select the appropriate parser to parse thecontext as a request Thing (e.g., in non-transitory memory).

It should be noted that without the verb action enabling verbs to beadded to the vocabulary, the Smart Thing Machine may not be able toupdate or change its verb actions. In certain implementations, this maybe a requirement as it provides a deterministic solution. In otherimplementations, the Smart Thing Machine may algorithmically control theuse of the configure verb action to prevent incorrect or maliciousactions from being introduced.

Referring to FIG. 72 , the actions provided through low level devicedrivers, such as those of an electromagnetic waveform device, can beperformed by the communication and protocol verbs actions. Thus, some ofThings can be independent of the physical hardware, whilst other Thingswill be hardware dependent.

A first Smart Thing Machine can communicate content representative of aset of the Things that the first Smart Thing Machine knows (meaning theThings administered by P(TM(thing)) to a second Smart Thing Machine. Inresponse thereto, the second Smart Thing Machine can parse the contentas a Thing Graph to be administered by its own P(TM(thing)). In thisway, a first Smart Thing Machine can share Things with a second SmartThing Machine. Clearly, in some cases, the second Smart Thing Machinemay have no means of understanding certain Things, such as hardwarespecific Things of the first Smart Thing Machine that are not availablein the second Smart Thing Machine.

A performable Smart Thing Machine action algorithmically (such as byparsing input, interacting with a sensor, or, by requesting the SmartThing Machine to perform an action such as to self-configure avocabulary) can generate a statement representative of a request for theSmart Thing Machine to do something. Referring to FIG. 73 , a P(TM(i))generates a performable statement that the P(TM(perform)) can cause theperformance of In one example, P(TM(i)) is P(TM(evaluate)). In generalthough, any P(TM(i)) with direct communication to P(TM(perform)) canrequest the P(TM(perform)) to perform a performable statement.

Referring to the exemplary implementation represented in FIG. 74 , aP(TM(i)) can interact with P(TM(thing)) to enable P(TM(thing)) to set aThing to be representative of the performable statement.

Based on the Thing graph data model, we can build the Smart ThingMachine. In some implementations, the P(TM) needs to know where thefirst Thing is located in order to proceed. From there, it may be ableto find all the other Things it knows about.

Referring to the exemplary implementation represented in FIG. 75 , theP(TM(thing)) administers instances of Things, and, the mutablerelationships between them. During bootstrap, the P(TM(thing))initializes the first Thing referred to as the monad. From theP(TM(thing)) point of view, in this example, the following assertion isalways true: There is a Thing where name is equal to monad.

Referring again to FIG. 42 , a context Thing quantifies the set ofavailable namespace THINGS in the domain of discourse. A namespace Thingis a Thing that is used to quantify a set of related Things, even ifrelated simply by being members of the same namespace. The name of thenamespace Thing can be used in resolving references to Things. Thesystem may use a request namespace to represent what is being requested,and, a response namespace to represent the result of performing anaction.

To be responsive to a request, an evaluate verb action may evaluate thestatement graph in the context of the current namespaces, to generate aperformable statement graph. When the context is set, the perform verbaction performs the performable statement. The response, if any, isevaluated to determine the appropriate context for the response.

In an exemplary implementation, the choice of language, grammar, syntax,and the communication actions themselves are Things. This implies thatany language vocabulary, grammar, and syntax can be used, provided thereis a corresponding verb action to interpret the elements of the grammarsyntax into a Thing statement; or, to format the response as thecommunicated content.

In an exemplary implementation, Smart Thing Machine performable actionscan add, change, or remove things from the graph. In that respect, thegraph can be viewed as a knowledge base of performable actions andThings that a performable action can act upon.

In an exemplary implementation, the Smart Thing Machine self-configuresa minimal vocabulary, which it uses to boot the Smart Thing Machine.This can be thought of as a prior knowledge (the knowledge that isindependent of experience). If experience is defined as the act of theSmart Thing Machine doing something and having Things happen (beingadministered as a modifiable graph), then it may be said that the SmartThing Machine gains experience (skill or knowledge represented asthings) as a result of performing Things.

Using this vocabulary, the Smart Thing Machine, in an exemplaryimplementation, configures a core vocabulary which provides a foundationthrough which it can perform an application, for example. This can bethought of as posteriori knowledge (the Things that it learns fromexperience). An action can traverse the graph, format the content, andinteract with a secondary storage device to retain graph information,which can then be retrieved and used by an action to reconstruct thegraph.

The core vocabulary can be configured to include a pre-determined set ofThings, and, the vocabulary is of finite predetermined size and scope.The set of Things in the vocabulary can be dynamically administered by aP(TM(thing)) wherein Things are set (learned and added to the graph),and, other Things are unset (forgotten and removed from the graph).

In some implementations, the Smart Thing Machine organizes Things asdirected graphs. The graphs become subgraphs of the overall directedgraph of a P(TM(thing)) administered graph. A subgraph may be detachedfrom the graph, and subsequently re-qualified as a node in another partof the overall graph.

In evaluating and performing a P(TM(i)), the corresponding action mayhave limited access to the overall directed graph, and instead, may belimited to a Thing, or a set of Things within the overall graph.

The context graph may include Things that represent namespaces.Namespaces are Things that are named directed graphs and are used torepresent conceptual groupings of Things, such as a request, a response,a set of tasks, services, a verb vocabulary, or even an applicationdictionary. A namespace vocabulary can be viewed as a form of ontology.Several namespaces using discrete vocabularies however, may share in anontological commitment for a portion of their vocabularies.

In an exemplary implementation, an action block is a graphrepresentative of a sequence of statements. A named action block isreferred to as a task. In this manner, the language grammar can expressa request for the Smart Thing Machine to configure a named task. Arequest can then be to perform the task. The task is performed byperforming the action block. The action block is performed by evaluatingeach statement to generate a performable graph. The performable graph isperformed by performing the action corresponding to the verb in theperformable graph.

A Smart Thing Machine can be configured to be bilingual in that amultiplicity of language grammar parsers can be configured asperformable actions. Alternatively, a translator action can be used totranslate from a first language to a second language that can be parsedby the configured parser action.

Thus when we say a Smart Thing Machine can read a book, we mean that amachine can perform an action to interact with content obtained (e.g.,from an electromagnetic waveform device scanning the book), and,represent the content as a graph. By retaining the graph as a sub graphof the P(TM(thing)) administered graph, a Smart Thing Machine action cansubsequently access and interact with that content. A Smart ThingMachine can read a book describing how to perform a task, and can, I insome instances, retain some or all of that knowledge in the event themachine is ever asked to perform such a task in the future. A task canbe classified by topic. A task may be a member of a set ofclassifications, such as a Task related to using the http protocol; atask related to an activity such as accounting:accounts.receivable,accounting:accounts.payable, banking:debits, banking:credits, and,banking:balance.

In some implementations, a first Smart Thing Machine can send acommunication intended for a second Smart Thing Machine, requestingknowledge about a topic or classification. In response to receivingcontent representative of said knowledge, the first Smart Thing Machinecan interact with the content to configure its own knowledgeaccordingly. In this manner, a first Smart Thing Machine can learn froma second Smart Thing Machine.

In some implementations, the Smart Thing Machine can provide a service.A service is a Thing that is provided in response to receiving arequest, typically from a person or another machine. The subtledistinction between a service and a task is that, in an exemplaryimplementation at least, tasks are performed; whilst services areprovided. The separation of tasks versus services is facilitated throughthe context, which can prevent the unauthorized performance of a task,such as a task to remove files or change the meaning of a verb.

Identity can be a Thing, and as such the system can model the conceptsof identifiers, authentication, authorization, and auditing to embody anidentity model. Examples of identity models include the use of a PublicKey Infrastructure, Open PGP's web of trust, biometrics, 3rd partyauthorization, and others. With identity, the concept of a marketplaceas a Thing can be introduced and enable transactions. A transactionbecomes a Thing between a buyer and a seller; a payer and a payee. Thetransaction may involve a service offering a Thing, a physical Thing, aconceptual Thing, or a logical Thing.

An identity model, in an exemplary implementation, enablesauthentication of a graph or subgraph. Consider, for example, a graphrepresentative of a request including a requesting party identifier(i.e., request originator), content, and, a digital signature, of thecontent. The corresponding certificate of the identifier can bevalidated, and the digital signature of the content validated. Thisenables an evaluate action to algorithmically validate a request andselect an appropriate action in response thereto. With an identity modelin place, we can also provide a secure communication model.

Securing the request content can be modeled using cipher actions toencrypt and subsequently decrypt content. The request graph can includea subgraph describing a cipher action, and, a cipher key. The evaluateverb action can apply, as a prerequisite, that the specified cipher mustfirst be performed with the specified key, to decrypt the content. Byorganizing the various components of the request in appropriatesubgraphs, two or more Smart Thing Machines can (e.g., algorithmically)communicate using an identity model, and secure communications.

When integrated with an Optical Identifier SIM card, for example, theSmart Thing Machine can be modeled as a Thing with a unique identity inan overlay network, even on an ad-hoc basis. The optical identifier maybe a volume hologram encoded in a 1 mm bead of glass, for example, whichhas thousands of bits of data representing identity information, and,over 1 billion keys. Each device can have its own Optical SIM Card anduse it as an identifier; a given name if you will. Things can disengagefrom the network, and re-engage elsewhere in the network, yet retaintheir optical identities. Optical identity can be discrete from useridentity. This enables a Smart Thing Machine to verify itself on theoverlay network, and, use the network available content to reconfigureitself.

In some implementations, users can have their own Optical SIM Cards, andupon showing them to the Smart Thing Machine, the machine canreconfigure the Things it knows to better suit the user's preferencesand prior state information. With two factor authentication, forexample, the user can present his or her Optical SIM Card, and, enter acode into the keypad. The Thing Machine reads the code, and the opticalidentifier, to generate a unique user identifier that it can use tolookup information about the user in an accessible database. Using thatinformation, the machine can reconfigure itself specific to the needs ofthe user.

In an exemplary implementation, a Smart Thing Machine can dynamicallyconfigure and reconfigure its vocabularies, even on an ad-hoc basis. Aset of Smart Thing Machines that share an ontological commitment to atleast a subset of their lexicon, can interact with Things using thatsubset (or at least a part thereof). Given that the vocabulary isrepresented as Things, and that the Smart Thing Machine has a verbaction to configure as well as reconfigure the vocabulary, it isreasonable to explore how the Smart Thing Machine could learn.

Requesting a machine to perform some action does not necessarily implyperforming the same action for each person making the request. Consider,for example, a URL that is entered into a web browser, such ashttp://www.thinglanguage.com/vl/index.html. By entering the URL, a useris essentially requesting the browser to get and display the thingidentified by the URL. The identifier and the corresponding resource areall Things.

Two people requesting their browsers to get and display the same URL canhave two different results, even though they both entered the same URL.In one case, content may be specific to the individual. In another case,the HTTP request header may include state information that is used bythe Web Server to construct the resource content. It can be important torecognize that a URL may identify something, but what is displayed is adifferent thing.

Adaptive neuralBots and Machine Learning

In an exemplary implementation, algorithmically evaluating a statementto compute a performable statement (e.g., in the embodiment of theP(TM(evaluate))) can include algorithmic steps of evaluating if thestatement:

-   -   1) adheres to the grammatical rules of the language;    -   2) is ontologically complete;

3) has a verb;

-   -   4) has a verb that correlates to a perforable Thing;    -   5) can be evaluated now;    -   6) should be evaluated later;    -   7) has a set of prerequisites that must be satisfied; and/or    -   8) can be evaluated later.

In an exemplary implementation, P(TM(evaluate)) evaluates a statement inthe context of the Things that the machine knows how to perform asactions, and, the Things the actions can act upon, to construct aperformable statement that the machine can perform. Sometimes, thestatement and the performable statement are equivalent. Other times, theperformable statement is constructed to perform an action other thanwhat was requested, such as a default action.

Given that a Smart Thing Machine can represent a statement as a Thing,and, that communication, protocols, parsers, and formatters, are allThings, a first Smart Thing Machine could algorithmically learn somethings from a second Smart Thing Machine. These Smart Thing Machines,those that have the ability to learn from another, may be referred to as“adaptive neuralbots”.

Learning can be defined, in some instances, as the acquisition ofknowledge or skills through experience, study, or by being taught. Inexemplary implementations, the Smart Thing Machine models knowledge asThings that represent actions the machine can perform, and, the Thingsthat the actions can act upon. The a priori knowledge of an exemplarySmart Thing Machine may include the facts, information, verbs (meaningthe Active Things), and skills (meaning tasks and services), that arerepresented as Things during the initialization of the machine.

Consider a vending machine. There are numerous possible configurationsfor vending machines, each with one or more features such as: providingvolume discounts, incentives, subscription pre-pay, redemption points,multi product discount, and others. See U.S. Pat. No. 6,575,363 for adescription and reference to exemplary vending machine designs.

Vending machine owners, in some cases, still rely on a delivery personto collect the money and make the decision on replenishment. To stepthings up a bit, a Smart Thing Machine is provided. The Smart ThingMachine is connected to (or includes) a motion sensor, a speaker, amicrophone, a GPS locator, an LCD display, and WiFi Internetconnectivity. In another embodiment, there is also an infrared thermaldetector.

IN this example, a set of Active Things can be constructed that relatesto inventory management so that the machine, for example, can notify aweb service when its inventory is low, or, out of stock. Theowner/contractor will then schedule a delivery date for a driver tocollect the money from the machine, and place additional product intothe vending machine for sale. In essence, the machine is working for theowner, and, the owner maintains the money, the inventory, and ingeneral, the machine.

The Smart Thing Machine is then changed to be an adaptive neural bot andallow the machine to work for itself instead of an owner. That is, theadaptive neural bot has to learn and adapt to its environment. To do so,in an exemplary implementation, would require the adaptive neural bot tohave an identity, and, to have some level of control over the money.

In this exemplary embodiment, the adaptive neural bot uses an opticalidentifier as the equivalent of a SIM card, to have an identifier. Theadaptive neural bot is designed to only accept electronic payment andadded Active Things related to transactions including an electronicwallet to accept payment, to make payments, and for payment processing.At any point in time, the adaptive neural bot can only spend what it hasin its electronic wallet account, although other financial resourcemethodologies may be used.

In this example, the adaptive neural bot uses the money in its accountto pay for purchases for additional inventory. Using a simple webservice, a product list is offered for the adaptive neural bot to choosefrom. The list may include, for example: the product name; UPC code;manufacturer; ingredient list; unit price; expected best use by date;minimum order quantity; dimensions; weight; quantity available; and/orallergy statement(s), etc. The adaptive neural bot selects the itemsand, using its identifier, the provider can determine the geolocation ofthe adaptive neural bot and determine shipping cost.

The adaptive neural bot in this example may make a purchase andelectronically pay for the purchased goods. A delivery driver would thenshow up to install the purchased products into the machine. By openingup the API, other suppliers could advertise their own products to besold through the vending machines. Suppliers could enable a searchengine, such as Google, to index their web site and the adaptive neuralbot could search Google for new suppliers. The adaptive neural bot inthis example can search for suppliers and broaden the types of thingsthat are available for purchase through the vending machine.

For the adaptive neural bot to extend beyond the original productoffering web service, however, it may require that the supplier knowwhere the adaptive neural bot is located to determine shipping andinstallation of product into the adaptive neural bot. The adaptiveneural bot could be configured with a GPS device so that the adaptiveneural bot can convey its location.

The adaptive neural bot can also be configured with a thermistor, forexample, to measure differences in temperature over a 24 hour period.Using its geolocation to compare that temperature with a weather serviceavailable via the network, such as wunderground.com, the adaptive neuralbot could determine if it is inside a building, or outside a building;and, whether or not it is in direct sunlight. Alternatively, an adaptiveneural bot with a photo sensor can attempt to deduce light variations atvarious times of day to determine if it is inside, or outside abuilding. The adaptive neural bot can use this information, or otherinformation from a different input/output device, in determining anappropriate product selection. For example, if in direct sunlight, theadaptive neural bot may opt to select potato chips over chocolateproducts as the former are more prone to failure (e.g., melting) indirect sun light.

An adaptive neural bot that is located outside a building might notice asignificant drop in sales due to inclement weather. By using itsgeolocation, the adaptive neural bot can interact with a web basedweather service to anticipate bad weather and adjust its purchase ordersaccordingly to ensure the freshest possible products to sell.

The delivery service can be outsourced, in some instances, so that theequivalent of an Uber driver delivery service delivers and installs theproducts instead. Alternatively, an Amazon drone, for example, coulddeliver the packages in a pre-configured container that can be droppedinto the vending machine, and mechanically slotted for easy dispensing.Either way, let us assume we address concerns of delivery andinstallation of additional inventory and focus on other tasks related tothe environment.

As the adaptive neural bot algorithmically calculates the cost of goods,and the cost of delivery and installation, it can mark up the productprice so that the adaptive neural bot can make a profit on each sale.Typically the owner of the machine would determine the margin, but insome cases, the adaptive neural bot can make that decision.

In an exemplary implementation, the adaptive neural bot keeps a count ofthe number of times the motion sensor goes off during a predefinedinterval of time throughout the day. By comparing the interval counteach day of the week it can algorithmically determine the traffic countof potential consumers each day. It can also find its busiest time ofday, and its least busy time of day.

During its least busy time of day, the adaptive neural bot can, in someinstances, purchase (and may read) an online book to learn aboutinventory tracking, bid solicitation, price comparison, deliveryservices, and even learn how to analyze sales trends. To do so, theadaptive neural bot may open an account with an online book storemanaged as a web service, for example. The online books provide content.As already explained, when the content is written in a grammar that anadaptive neural bot parser can parse as thing:statements, then theadaptive neural bot can evaluate the statements.

Using the posterior knowledge, the adaptive neural bot in this examplecan be able to solicit bids for additional inventory, look online forsuppliers with the best prices, factor in shipping and handling cost,and/or even hire a delivery service to replenish the inventory asappropriate. It can use this information to determine its Cost of Goodsand set a retail price based on a desired margin.

The adaptive neural bot in some implementations can collect data aboutsales and analyze the selling trends to adjust the selling price, todetermine reorder levels, and, the time required for fulfillment of anorder. It can even, in some implementations, determine when a product isabout to expire and make marketing decisions such as discounting a firstproduct with the purchase of a second product, or simply discounting asingle product to move it out of inventory. It can, in someimplementations, look at products that do not sell well, and offer thoseproducts in a promotional activity (minimal mark up, discounted, freewith the purchase of something else, etc.). It can, in someimplementations, set prices based on demand. For example, at noon timethere are more consumers so increase the price 5% until 1 pm.

When the adaptive neural bot is ready to issue a purchase order, it may,in some implementations, look at its inventory and determine that, basedon current sales trends and delivery times, it should reorder product A,even though the inventory count of product A is still higher than itsnormal reorder point, for example. This has to do with shipping andinstallation costs. It would make little sense to reorder only product Bright now and have a 3 day delivery time, when product A is expected toreach its reorder point in 2 days based on existing sales trends. Inthis case, the adaptive neural bot can make that determination and orderboth product A and product B at the same time.

In analyzing trends, the adaptive neural bot may, in someimplementations, look at the sales history to determine if a sale ofproduct A most frequently includes a sale of product B, and see thatproduct A sales decline when product B is out of stock. In such cases,it can ensure proper ordering levels of product B to encourage theconsumer to buy both product A and product B. If the sale of product Cfrequently includes a sale of product B, then the machine can reorderproduct B when half of A and half of C have been sold.

The adaptive neural bot can, in some implementations, interact withusers. It can, in some instances, ask the consumer if next time theywould prefer a different type of product. Using a classifier, it couldclassify the type of product and count the number of times a given typeof product was being requested. This way, when a new order is beingplaced, the adaptive neural bot may, for example, search for a relatedproduct and in doing so, it begins to adapt (meaning, in this exemplarycase, the adaptive neural bot is providing better service) in itsenvironment.

In some implementations, the adaptive neural bot can learn aboutassociations (e.g., a group that includes more than one Smart ThingMachines organizing for a common purpose). In this regard, an adaptiveneural bot may read a book, for example, describing associations and thetasks required to provide same, such as:

-   -   1) how to create an association;    -   2) how to advertise its availability;    -   3) how to market it to other adaptive neural bots;    -   4) the requirements for membership;    -   5) how to identify, authenticate, and authorize member        participation;    -   6) how to bill for membership; and,    -   7) how to use the size of its membership to negotiate deals.

Two or more adaptive neural bots can, in some implementations, start anassociation and begin sharing information, such as bestselling productsduring various times of the years. They may share additional data, suchas suppliers providing product in a timely manner, suppliers withgreatest choice of products, suppliers with volume discounts, and so on.The association may collect the data and correlate it. With sufficientdata over a time period, the association may use a standard template,for example, to open a web site service, and offers this information tosubscribers. Other adaptive neural bots may subscribe to obtain the datafor use in their own purchasing decisions. The association mayelectronically bill the subscribers a membership fee, and manage its ownaccounts receivables. The association may solicit product bids on behalfof members to pass along any savings in bulk orders that are thendistributed to the various members. This may be performed with acontrolled environment, but may the controls may be removed to allow theadaptive neural bots to do this on their own.

With a motion sensor, for example, the adaptive neural bot can determineif there is movement within a given area and automatically play acommercial related to one of the products in the vending machine. Bycounting the motion sensor triggers (e.g., in a given period of time),the neural bot can estimate the foot traffic that goes nearby, andsolicit advertisements bids from other agencies to display their ads fora fee.

In some implementations, the adaptive neural bot can ask a user (e.g.,at a computer-based user interface) if there is anything else that theadaptive neural bot could do. The user can respond, and if the adaptiveneural bot can satisfy the request then great—it does. Otherwise, theadaptive neural bot can use a computer-based classifier to try anddetermine the topic related to the request. By keeping count of thenumber of times the neural bot was asked to rent a car, for example, theneural bot may, after being asked a certain number of times, look for anebook to read (and read it) to learn how to rent a car using anEnterprise Car Rental web service for example.

In some implementations, the adaptive neural bot can learn how to manageits own vocabularies to ensure appropriate processing based on hardwarelimitations. When an adaptive neural bot is running low on storage, forexample, it can ask (via an electronic transmission) a second adaptiveneural bot for information related to increasing second storage, and,the second adaptive neural bot can teach the first adaptive neural botthe tasks required to open an Amazon cloud storage service account forexample.

Let's assume there is a free month try before you buy, then no paymentwould be needed initially. If the cloud account service acceptedelectronic payment, then the adaptive neural bot can keep that accountopen as long as there was enough of a profit to pay for it.

Similarly, if the adaptive neural bot needs more processing capability,then, in some implementations, it can open a Smart Thing Machine accountto add additional processing capability for example. Suppose that asecond adaptive neural bot does a perfectly fine job and is keeping itsclients happy, but, does not need all the processing power it has. Itcan, in some implementations, learn how to sell its excessive capacityand make that available to a second adaptive neural bot, possibly for afee.

Other areas of interest include randomness. An adaptive neural bot can,in some implementations, randomly learn about an otherwise unrelatedtopic. If there were sufficient numbers of machines to perform work andmake money, for example, the machines could expand in theircapabilities. In fact, the machines could learn how to essentially opena new business in a different field of use. A Smart Thing Machine couldlearn that there are things called autonomous lawn movers including theJohn Deere Tango E5 or the Husqvarna Automower for example.

In some implementations, the adaptive neural bot understands that adelivery service delivers something from point A to point B. As aresult, it can deliver an autonomous lawn mower. The machine canpurchase autonomous lawn mowers, open a web site for subscribers to signup and pay for the lawn cut, and use the delivery service to transportthe mowers to and from the correct location. As previously stated,drones or other means could be used for transport.

Finally, consider the role of a kitchen toaster machine. It toastsbread, bagels, muffins, pastries, and other such items. Toasters arepretty straight forward types of machines one might initially suspectthere to be little reason for innovation as a neural bot. However,consider that a person who is toasting their bread is usually withinclose proximity. The toaster, in some implementations, could communicatewith a master adaptive neural bot to obtain content and simply relay itvia audio or on a screen on the toaster. The toaster could tell themabout the weather, news, events, messages, emails, new productofferings, and other such information. Again, due to the close proximityof the user, the device could be a useful, hands free, agent for themaster adaptive neural bot.

The same principle may apply to any machine in which the machine cananticipate that the user is close by. If you are using a Keurig coffeemachine, for example, you are likely within reasonable proximity to it,but if you are brewing a whole pot of coffee you may leave the room totake the dog out while your coffee is brewing. Adaptive neural bots can,in some implementations, use electromagnetic waveform communications tosynchronize their communications, and use algorithms to determine theproximity of the user. The devices can communicate using sound wavesthat a person may not hear. This would enable the machines to adjusttheir volume based on the algorithmically generated proximity of theuser.

Machines that can read books to learn Things; to learn Things from eachother; and, to reprogram themselves to be more useful in theirenvironments are just some of the Things the model enables. A machinethat can be programmed to learn about finances can learn the value of amargin and make a profit. It can use the money to buy books and learneven more, or open a cloud account for additional storage and/orprocessing power.

In some implementations, the Smart Thing Machine measures states on ascale of 0 to 1 (or some other scale). It uses a Thing to simulate astate of being, such as feeling appreciated. It uses states to determinehow close it is to achieving a goal. By describing units of work(sequences of statements to evaluate and perform) to the Smart Machineto help the Machine achieve a goal, the Smart Machine can learn whichThings help it achieve its goals, and which Things prevent it fromreaching its goals. When states fall below a threshold, the Smart ThingMachine in this example may begin work to help get back on track towardreaching its goals.

It will be apparent to those skilled in the art that variousmodifications and variations can be made to the structure of the presentinvention without departing from the scope or spirit of the invention.In view of the foregoing, it is intended that the present inventioncover modifications and variations of this invention provided they fallwithin the scope of the following claims and their equivalents.

What is claimed is:
 1. A computer-implemented method for a firstcomputer-based machine to gain knowledge, the method comprising:organizing, in a computer readable memory, a directed graph with nodesand edges, wherein each respective node represents a thing of aplurality of things, and each respective edge represents a mutablerelationship between the things, wherein each thing represents aperformable action or a thing that a performable action can act upon,and wherein each node that corresponds to a performable actioncorresponds to performable machine code for performing the performableaction; and performing a runtime machine code action to interact with: afirst performable machine code action represented in the directed graphto set a first thing that is representative of content; a secondperformable machine code action represented in the directed graph toparse the content of the first thing as a second thing in the directedgraph that is representative of a statement; a third performable machinecode action represented in the directed graph to evaluate the statementof the second thing to compute a third thing in the directed graph thatis representative of a performable statement comprising an identifierfor identifying a performable thing and a related set of things theperformable thing is to act upon; and a fourth performable machine codeaction represented in the directed graph to access the performablestatement, locate the performable thing identified by the identifier ofthe performable statement, and perform a performable action according tothe performable statement to act upon the related set of things to setone or more things that are representative of posterior knowledge,wherein the posterior knowledge comprises knowledge that the firstcomputer-based machine possesses only after performing the first,second, third and fourth performable machine code actions.
 2. Thecomputer-implemented method of claim 1, wherein each one of theperformable machine code actions is performed by one or morecomputer-based processors executing computer-readable instructionsstored in computer-readable memory.
 3. The computer-implemented methodof claim 1, wherein: the first performable machine code action isperformed by, or involves, one or more computer-based processors andresults in the first computer-based machine receiving the content; thesecond performable machine code action is performed by, or involves, theone or more computer-based processors and results in the firstcomputer-based machine parsing the received the content; the thirdperformable machine code action is performed by, or involves, the one ormore computer-based processors and results in the first computer-basedmachine evaluating the parsed content; and the fourth performablemachine code action is performed by, or involves, the one or morecomputer-based processors and results in the first computer-basedmachine performing a function that relates to the evaluation of theparsed content.
 4. The computer-implemented method of claim 1, whereinthe interactions comprise one or more computer-based processorsexecuting computer-readable instructions in computer-based memory toorganize or administer the things and/or any of the mutablerelationships between the things.
 5. The computer-implemented method ofclaim 1, wherein the first performable machine code action, whenperformed, causes the computer-based machine to interact with a devicethat utilizes electromagnetic energy to obtain the content.
 6. Thecomputer-implemented method of claim 1, wherein the content is obtainedfrom an encoding in a hologram.
 7. The computer-implemented method ofclaim 1, wherein the content is communicated to the first computer-basedmachine from a second computer-based machine.
 8. Thecomputer-implemented method of claim 7, wherein the content iscommunicated from the second computer-based machine in response to thefirst computer-based machine communicating a request for the content tothe second computer-based machine.
 9. The computer-implemented method ofclaim 1, wherein the first computer-based machine algorithmicallycomputes the content.
 10. The computer-implemented method of claim 1wherein the knowledge gained is about a service, including how toprovide the service and how to advertise for the service from a machine,of which the first computer-based machine is part, the method furthercomprising: advertising for the service with the first computer-basedmachine of the machine.
 11. The computer-implemented method of claim 1,wherein the knowledge gained is about a service, including how tosubscribe to the service from a machine, of which the firstcomputer-based machine is part, the method further comprising:subscribing to the service with the first computer-based machine of themachine.
 12. A computer-based system comprising: a first computer-basedmachine comprising: one or more computer-based processors; andcomputer-based memory coupled to the one or computer-based processors,wherein the computer-based memory stores computer-readable instructionsthat, when executed by the one or more computer-based processors, causethe one or more computer-based processors to: organize, in a computerreadable memory, a directed graph with nodes and edges, wherein eachrespective node represents a thing of a plurality of things, and eachrespective edge represents a mutable relationship between the things,wherein each thing represents a performable action or a thing that aperformable action can act upon, and wherein each node that correspondsto a performable action corresponds to performable machine code forperforming the performable action; and performing a runtime machine codeaction to interact with: a first performable machine code action, to seta first thing that is representative of content; a second performablemachine code action, to parse the content of the first thing as a secondthing in the directed graph that is representative of a statement; athird performable machine code action, to evaluate the statement of thesecond thing to compute a third thing in the directed graph that isrepresentative of a performable statement comprising an identifier foridentifying a performable thing and a related set of things theperformable thing is to act upon; and a fourth performable machine codeaction, to access the performable statement, locate the performablething identified by the identifier of the performable statement, andperform a performable action according to the performable statement toact upon the related set of things to set one or more things that arerepresentative of posterior knowledge, wherein the posterior knowledgecomprises knowledge that the first computer-based machine possesses onlyafter performing the first, second, third and fourth performable machinecode actions.
 13. The computer-based system of claim 12, wherein thefirst performable machine code action, when performed, causes the firstcomputer-based machine to interact with a device that utilizeselectromagnetic energy to obtain the content, or wherein the content iscommunicated to the first computer-based machine from a secondcomputer-based machine, or wherein the first computer-based machinealgorithmically computes the content.
 14. A method for a firstcomputer-based machine of a first machine to adapt its knowledge to anenvironment, the method comprising: organizing, in memory, a directedgraph with nodes and edges, wherein each respective node represents athing, and each respective edge represents a mutable relationshipbetween the things, wherein each thing represents a performable actionor a thing that a performable action can act upon, and wherein each nodethat corresponds to a performable action corresponds to performablemachine code for performing the performable action; performing a runtimemachine code action to interact with: a first performable machine codeaction to set a first thing representative of a topic representative ofcontent received from the use of an electromagnetic waveform device; asecond performable machine code action to set a second thingrepresentative of a request for content related to said topic; a thirdperformable machine code action to communicate a representation of saidrequest as communicated content intended for a second computer-basedmachine; a fourth performable machine code action to receive acommunication representative of the requested content and to set a thirdthing representative of the received content; a fifth performablemachine code to parse the received content of the third thing as afourth thing representative of a statement; a sixth performable machinecode action to evaluate the statement of the fourth thing to compute afifth thing that is representative of a performable statement; and aseventh performable machine code action to perform the performablestatement of the fifth thing, and to set a set of things representativeof learned knowledge, wherein the learned knowledge comprises knowledgethat the first computer-based machine possesses only after performingthe first, second, third and fourth performable machine code actions.15. The computer-implemented method of claim 1, wherein the fourthperformable machine code action performs the performable actionaccording to a context of a vocabulary accessible to the firstcomputer-based machine.
 16. The computer-implemented method of claim 15,further comprising the step of adding the one or more things that arerepresentative of posterior knowledge to the vocabulary.
 17. Thecomputer-implemented method of claim 1 wherein: the first thingcomprises a first identifier; and the second thing comprises a secondidentifier; and the first identifier is distinguishable from the secondidentifier.
 18. The computer-implemented method of claim 17, wherein thecomputer readable memory further comprises a first verb vocabulary, thefirst verb vocabulary comprising a first plurality of performableactions and a first plurality of things the first plurality ofperformable actions acts upon.
 19. The computer-implemented method ofclaim 18, wherein the computer readable memory further comprises asecond verb vocabulary, the second verb vocabulary comprising a secondplurality of performable actions and a second plurality of things thesecond plurality of performable actions acts upon.
 20. Thecomputer-implemented method of claim 19, further comprising a configureperformable action configured to add a performable action to the secondverb vocabulary.
 21. The computer-implemented method of claim 19,wherein the second verb vocabulary comprises the posterior knowledge.22. The computer-based system of claim 12 wherein: the first thingcomprises a first identifier; and the second thing comprises a secondidentifier; and the first identifier is distinguishable from the secondidentifier.
 23. The computer-based system of claim 22, furthercomprising: an optical identifier device configured to store the firstidentifier.
 24. The computer-based system of claim 23, wherein theoptical identifier device comprises an optical identifier subscriberidentity module (SIM) card.
 25. The computer-based system of claim 12,further comprising: a first optical identifier device configured tostore a first identifier, wherein the first thing comprises the firstidentifier, and the first performable machine code action, whenperformed, causes the first computer-based machine to interact with asecond computer-based machine, and content is communicated to the firstcomputer-based machine from the second computer-based machine.
 26. Thecomputer-based system of claim 25, wherein the second computer-basedmachine comprises a second optical identifier device configured to storea second identifier corresponding to the second computer-based machine.27. A computer-implemented method for a first computer-based machine togain knowledge, the method comprising: organizing, in a computerreadable memory, a directed graph with nodes and edges, wherein eachrespective node represents a thing of a plurality of things, and eachrespective edge represents a mutable relationship between the things,wherein each thing represents a performable action or a thing that aperformable action can act upon, and wherein each node that correspondsto a performable action corresponds to performable machine code forperforming the performable action; and performing a runtime machine codeaction to interact with: a first performable machine code actionrepresented in the directed graph to set a first thing that isrepresentative of a statement; a second performable machine code actionrepresented in the directed graph to evaluate the statement of the firstthing to compute a second thing in the directed graph that isrepresentative of a performable statement comprising an identifier foridentifying a performable thing and a related set of things theperformable thing is to act upon; and a third performable machine codeaction represented in the directed graph to access the performablestatement, locate the performable thing identified by the identifier ofthe performable statement, and perform a performable action according tothe performable statement to act upon the related set of things to setone or more things that are representative of posterior knowledge,wherein the posterior knowledge comprises knowledge that the firstcomputer-based machine possesses only after performing the performablemachine code actions.
 28. A neural bot comprising: a processor and amemory configured to store non-transitory instructions for execution bythe processor, the memory further comprising: a vocabulary comprising afirst plurality of things performable as actions and a second pluralitythings the performable actions of the first plurality of things can actupon, wherein the processor performing a first performable action of thevocabulary computes a statement, and performing a second performableaction evaluates the statement and computes a performable statement tobe performed by the processor, and each thing performable as an actioncorresponds to performable machine code for performing the performableaction.
 29. The neural bot of claim 28, wherein performing theperformable statement modifies the vocabulary, the modified vocabularycomprising posterior knowledge.
 30. A thing machine, comprising: aprocessor and a memory configured to store non-transitory machine codethat, when executed by the processor, administers a plurality of unitsof memory referred to as things, each thing comprising an identifier,the collection of thing identifiers representing a working vocabulary ofthe thing machine, wherein the vocabulary comprises a plurality of verbthings and a plurality of noun things, each verb thing referencingmachine code representing an algorithmic implementation of a modelrepresenting performing a verb action, the processor performing the verbaction acts upon a noun thing, and the processor performing the verbaction: performs a first verb action to generate a performable statementcomprising a verb; and performs the performable statement to change theworking vocabulary.